概述

写C的时候，我们是面向过程的，而在C++中，我们则是面向对象，面向对象的思想可谓是一个革新，这也是使得构建缤纷的代码世界变得更加容易。本文中我想联系生活中的实际来说说和面向对象有关的事情。在此感谢阅读。

类，对象，属性，方法

在C++中，我们把

new和malloc

在C中，我们使用malloc来为指针分配空间，并且可以自己去操控这一片空间，C++中提供了类似的new操作符来达到和malloc函数同样的效果

1. 分配一个int的空间

   int* p = new int(10);//c++,这里面的10表示*p=10，而不是10个int空间
   delete p ;//释放空间
   

   等价的C操作如下

   int* p = (int*)malloc(sizeof(int));//c
   *p = 10 ;
   free(p)
   

2. 分配10个int空间

   int* p = new int[10];//c++,这里面的10表示10个空间，里面的内容没有被初始化
   delete[] p;//注意是delete[]
   

   //等价的C操作如下
   int* p = (int*)malloc(10*sizeof(int));//c
   free(p);
   

引用

看下面的程序

void swap(int& value1,int& value2){
	value1=19;
	value2=90;
}

int main(){
	int a = 0 ;
	int b = 0 ;
	swap(a,b);//a,b可以被改变
	return 0;
}

其实本质是这样的

void swap(int* const value1,int* const value2){
	*value1=19;
	*value2=90;
}

int main(){
	int a = 0 ;
	int b = 0 ;
	swap(&a,&b);//a,b可以被改变
	return 0;
}

我们从中可以看到，引用的本质就是一个常量指针，或者说引用是为一个变量起了一个别名。由于是常量指针，所以引用的两个性质可以得到合理解释：

1. 引用必须要初始化：假设引用没有初始化，那么它将指向内存中一块未知的区域，而引用又是常量指针，所以我们无法修改其值，此时对引用的操作是危险的

2. 引用不可以更改值：因为引用是常量指针

引用的赋值和常量引用

有一个操作类似更改引用，但其实是引用的赋值，我们来看一下

	int a = 10 ;
	int b = 20 ;
	int& c = a;
	c =b ;

在内存中的行为其实是这样的

c=b并不是意味着c现在是b的别名，而是表示 a的引用c 把b的值 赋给了 a
我们在上文提到了，引用是常量指针，比如

int a = 20;
int& c = a;

等价于

int a = 20;
int* const c = &a;

引用让我们拥有了修改a的权限，但是如果我们只希望具有对a的读权限，而希望禁止写a，我们可以使用常量引用

int a = 20 ;
const int& b = a ;
//a = 30 该操作是禁止的
//常量引用等价于 const int* const b = &a;

综上

函数

1. 函数的默认参数

   void fun(int a =20){
       cout<<a<<endl;
   }
    int main() {
        fun();
   }
   

   该操作是被允许的

2. 函数重载

   int add(int a ,int b){
   	return a+b ;
   }
   double add(double a ,double b){
   	return a+b ;
   }