C++引用和指针

C++引用和指针

引用

引用reference为对象起了另外一个名字，引用类型引用refers to另外一种类型，通过将声明符写成&d的形式来定义引用类型，其中d是生命的变量名

int ival = 1024;
int &refVal = ival; //refVal指向ival(是ival的另一个名字)
int &refVal2;		//报错：引用必须被初始化

一般在初始化变量时，初始值会被拷贝到新建的对象中
然而定义引用时，程序把引用和它的初始值绑定在一起，而不是将初始值拷贝给引用
一旦初始化完成，引用将和它的初始值对象一直绑定在一起
因为无法令引用重新绑定到另外一个对象，因此引用必须被初始化

引用即别名

引用并非对象，他只是为一个已经存在的对象起的另一个名字

定义了一个引用之后，对其进行的所有操作都是在与之绑定的对象上进行的

refVal = 2;      //把2赋给refVal指向的对象，也就是ival
int ii = refVal; //与ii = ival执行结果相同

为引用赋值，实际上是把值赋给了与引用绑定的对象
获取引用的值，实际上是获取了与引用绑定的对象的值

同理，以引用作为初始值，实际上是以与引用绑定的对象作为初始值：

//refVal3绑定到了与refVal绑定的对象上，也就是绑定到iVal上
int &refVal = refVal;
//利用与refVal绑定的对象的值初始化变量i，i被初始化为iVal的值
int i = refVal;

引用的定义

允许在一条语句中定义多个引用，其中每个引用标识符都必须以符号&开头：

int i = 1024,i2 = 2048; //i和i2都是int
int &r = i,r2 = i2;     //r是一个引用，与i绑定在一起，r2是int
int i3 = 1024,&ri = i3; //i3是int，ri是一个引用，与i3绑定在一起
int &r3 = i3,&r4 = i2;  //r3和r4都是引用

除了之后会讲道德两种例外情况，其他所有引用的类型都要和与之绑定的对象严格匹配

int &refVal4 = 10;	//错误：引用类型的初始值必须是一个对象
double dval = 3.14;
int &refVal5 = dval; //错误：此处引用类型的初始值必须是int型对象

指针

指针是指向另一种类型的复合类型，和引用类似，实现了对其他对象的间接访问，然而引用和指针有很多不同点：

1. 指针本身就是一个对象，允许对指针赋值和拷贝，而且在其生命周期内它可以先后指向几个不同的对象；引用并非对象，他只是为一个已经存在的对象起的另一个名字，一旦初始化完成，引用将和它的初始值对象一直绑定在一起
2. 指针无需在定义时赋初始值，和其他内置类型一样，在块作用域内定义的指针如果没有初始化，也将拥有一个不确定的值；因为无法令引用重新绑定到另外一个对象，因此引用必须被初始化

获取对象的地址

指针存放某个对象的地址，想要获取该地址就要用取地址符号（操作符&）

int ival = 42;
int *p = &ival; //p存放变量ival的地址(p的指向变量ival的指针)

第二条语句把p定义为一个指向int的指针，随后初始化p令其指向名为ival的int对象，由于引用不是对象，没有实际地址，所以不能定义指向引用的指针'

通常，所有指针的类型都要和它所指向的对象严格匹配

double dval;
double *pd = &dval; //正确：初始值是double型对象的地址
double *pd2 = pd;   //正确：初始值是指向double对象的指针

int *pi = pd;		//错误：指针pi的类型和pd的类型不匹配
pi = &dval;			//错误：试图把double型对象的地址赋给int指针

指针值

指针的值(即地址)应该属于下列4种状态之一：

1. 指向一个对象
2. 指向紧邻对象所占空间的下一个位置
3. 空指针，没有指向任何对象
4. 无效指针，上述情况之外

利用指针访问对象

如果指针指向了一个对象，允许使用解引用符(操作符*)来访问该对象

int ival = 42;
int *p = &ival; //p存放着变量ival的地址，或者说p是指向变量ival的指针
cout<< *p		//由符号*得到指针p所指向的对象，输出42

对指针解引用会得出所指的对象，因此如果给解引用的结果赋值，实际上也就是给指针所指的对象赋值

*p = 0;
cout<< *p;

空指针

不指向任何对象，在试图使用一个指针之前可以先检查其是否为空，以下是生成空指针的几个方法：

int *p1 = nullptr; //C++11
int *p2 = 0;
int *p3 = NULL;    //include<cstdlib>

现在的C++程序最好使用nullptr，同时尽量避免使用NULL

把int变量直接赋值给指针是错误的操作，即使int变量的值恰好等于0

int zero = 0;
pi = zero;    //错误

赋值和指针

指针和引用都能提供对其他对象的间接访问，然而在具体实现细节上二者有很大不同，其中最重要的一点就是引用并非都是一个对象，一旦定义了引用，就无法再令其绑定到其他对象，之后每次使用这个引用都是在访问它最初绑定的对象

指针的和它存放的地址之间就没有这种现实，和其他变量(只要不是引用)一样，给指针赋值就是令他存放一个新的地址，从而指向一个新的对象

int i = 42;
int *pi = 0;	//pi被初始化，但没有指向任何对象
int *pi2 = &i;	//pi2被初始化，存有i的地址
int *pi3;		//如果pi3定义于块内，pi3的值无法确定

pi3 = pi2;		//pi3和pi2指向同一个对象
pi2 = 0;		//现在pi2不指向任何对象了

有的时候想搞清楚一条赋值语句到底是改变了指针的值还是指针所之乡的对象的值不太容易，最好的办法就是记住赋值永远改变的是等号左侧的对象：

pi = &ival  //pi的值被改变，现在pi指向了ival

上面代码意思为为pi赋一个新的值，也就是改变了那个存放在pi内的地址值，相反的，如果写出如下语句：

*pi = 0;    //ival的值被改变，指针pi并没有改变

则*pi(也就是指针pi指向的那个对象)发生改变

其他指针操作

只要指针拥有一个合法值，就能将它在用条件表达式中，和采用算术值作为条件遵循的规则类似，如果指针的值是0，条件取false

int ival = 1024;
int *pi = 0;	   //pi2是一个合法的指针，存放着ival的地址
int *pi2 = &ival;  //pi的值是0，因此条件的值是false
if(pi)
    //pi值是0，false
if(pi2)
    //pi2指向ival，ival的值不等于0，true

对于两个类型相同的合法指针，可以用 == 或者 != 来比较他们，如果存放的地址相同则相等，反之则不等

地址相同存在着三种可能：

1. 都为空
2. 指向同一个对象
3. 指向了同一个对象的下一个地址

一个指针指向某对象，另一个指针指向另一个对象的下一个地址，两个指针也有可能相等

void*指针

void* 指针是一种特殊的指针类型，以用于存放任意对象的地址，和其他指针类似，一个void* 指针存放着一个地址，不同的是，我们不了解该地址中是个什么类型的对象

double obj = 3.14, *pd = &obj; 
void *pv = &obj; //obj可以是任意类型的对象
pv = pd;		 //pv可以存放任意类型的指针

以void* 的视角来看内存空间也仅仅是内存空间，没办法访问内存空间中所存的对象

复合类型的声明

首先我们知道，一条定义语句可能定义出不同类型的变量

//i是一个int型变量，p是一个int型指针，r是一个int型引用
int i = 1024,*pi = &i,&r = i;

定义多个变量

误导人的写法：

int* p; //合法

int和 * 放在一起好像是这条语句所有变量的共同类型是int*一样，其实恰恰相反，基本数据类型是int， * 仅仅修饰了p而已，在该语句中声明其他变量并不起任何作用：

int* p1,p2; //p1是指向int的指针，p2是int

所以设计指针或者引用的声明，我们一般有两种写法：

int *p2, *p2

int *p1;
int *p2;

指向指针的指针

指针是内存中的对象，像其他对象一样也有自己的地址，因此允许把指针的地址再存放到另一个指针当中
通过 * 的个数可以区分指针的级别，** 是指向指针的指针， *** 表示指向指针的指针的指针：

int ival = 1024;
int *pi = &ival; //pi指向一个int型的整数
int **ppi = π //ppi指向一个int型的指针

解引用int型指针会得到一个int型的数，同样，解引用指向指针的指针会得到一个指针，此时为了访问最原始的对象需要对指针的指针做两次解引用，以下程序以三种不同的方式输出了ival的值

cout<<ival<<endl;
cout<<*pi<<endl;
cout<<**ppi<<endl;

指向指针的引用

引用本身不是一个对象，因此不能定义指向引用的指针，但指针是对象，所以存在对指针的引用

int i = 42;
int *p;		 //p是一个int型指针
int *&r = p; //r是一个对指针p的引用

r = &1;      //r引用了一个指针，因此给r赋值&i就是令p指向i
*r = 0;		 //解引用r得到i，也就是p指向的对象，将i的值改为0；

const的引用

对常量的引用与普通引用不同的是，对常量的引用不能被用作修改它所绑定的对象

const int ci = 1024;
const int &ri = ci;  //正确，引用及其对应的对象都是常量
ri = 2048;           //错误：r1是对常量的引用
int &r2 = ci         //错误：试图让一个非常量引用指向一个常量对象

对常量的引用是对const的引用，严格来说并不存在常量引用，因为引用不是一个对象，我们没有办法让引用本身恒定不变，由于C++并不允许随意改变引用所绑定的对象，所以从这层意义上理解的所有的引用都算是常量

我们之前提到引用的类型必须与其所引用的对象的类型一致，但是这里有其中一个例外：初始化常量时允许用任意表达式作为初始值，只要该表达式结果能转换成引用类型即可，尤其允许为一个常量引用绑定非常量的对象，字面值，甚至一般表达式：

int i = 42;
const int &r1 = i;		//允许const int&绑定到一个普通int对象上
const int &r2 = 42;		//正确：r2是一个常量引用
const int &r3 = r1 * 2; //正确：r3是一个常量引用
int &r4 = r1 * 2;		//错误：r4是一个普通的非常量引用

为什么呢？然后我们看看在这个绑定过程中发生了什么：

double dval = 3.14;
const int &ri = dval;

此处ri引用了一个int型整数，对ri的操作是整数运算，但dval却是一个双精度浮点数而非整数，因此为了确保让ri绑定一个整数，编译器把上述代码变成了：

double dval = 3.14;
const int temp = dval;
const int &ri = temp;

在这种情况下，ri绑定了一个临时量对象，所谓临时量对象就是当编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，我们也常把临时量对象称为临时量

对const的引用可能引用一个并非const的对象

int i = 42;
int &r1 = i;
const int &r2 = i; //r2也绑定对象i，但不允许通过r2修改i
r1 = 0;            //r1并非常量，i修改为0
r2 = 0;            //错误：r2是一个常量引用绑定

常量引用绑定非常量是合法行为，然而不允许通过该常量引用修改其绑定的非常量的值

指针和const

类似于常量的引用，指向常量的指针不能用于改变其所指对象的值，同时，想存放常量对象的地址，只能使用指向常量的指针：

const double pi = 3.14;
double *ptr = π		  //错误：ptr是一个普通指针
const double *cptr = π //正确：cptr可以指向一个双精度常量
*cptr = 42;				  //错误：不能给*cptr赋值

我们之前也提到指针类型必须与其指向对象的类型一致，但这里也有一个例外：

double dval = 3.14; //dval是一个双精度浮点数
cptr = &dval;		//正确，但不能通过cptr改变dval的值

const指针

指针是对象，而引用不是，因此我们允许把指针本身定为常量，也就是常量指针，常量指针必须被初始化，而且一旦初始化完成(存放在指针里的地址)就不能再改变

int errNumb = 0;
int *const curErr = &errUnmb;  //curErr将一直指向errNumb
const double pi = 3.14159;
const double *const pip = π //pip是一个 指向常量对象的 常量指针

这样的书写形式也隐含着一层意味：不变的是指针本身而非指向的那个值，也就是说指针本身是一个常量

指针本身是一个常量并不意味这不能通过指针修改其指向的对象的值，这取决于对象的类型：

*pip = 2.72 //错误：pip指向的对象是常量
*curErr = 1 //正确：curERR指向的是一个非常量整数

顶层const

指针本身是一个对象，但是它又可以指向另外一个对象，因此指针本身是不是常量和指针所指的是不是一个常量就是两个互相独立的问题，我们用这样区分：

• 顶层const表示指针本身是个常量
• 底层const表示指针所指的对象是一个常量

int i = 0;
int *const p1 = &i; 	  //不能改变p1的值，这是一个顶层const
const int ci = 42;		  //不能改变ci的值，这是一个顶层const
const int *p2 = &ci;	  //允许改变p2的值，这是一个底层const
const int *const p3 = p2; //靠右的是顶层const，靠左的const是底层const
const int &r = ci;		  //用于声明引用的const都是底层const

当执行拷贝操作时，常量是顶层const还是底层const区别就很明显了

其中顶层const不受什么影响：

i = ci;  //正确：ci是一个顶层const，无影响
p2 = p3; //正确：p2和p3指向对象类型相同，p3顶层const部分不影响

由于执行拷贝操作不会改变被拷贝对象的值，因此拷入和拷出的对象是否是常量都没什么影响

但是底层const就有限制了，拷入和拷出的对象都有必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换，一般来说非常量可以转换成常量，反之不行

int *p = p3;	   //错误：p3包含顶层const的定义，p没有
p2 = p3;		   //正确：p2和p3都是底层const
p2 = &i;		   //正确：int*能转换成const int*
int &r = ci;	   //错误：普通的int&不能绑定到int常量上
const int &r2 = i; //正确：const int&可以绑定到一个普通int上

比如p3既是顶层const也是底层const，拷贝p3时可以不去在乎它是一个顶层const，但是必须清楚它指向的对象得是一个常量，因此不能用p3去初始化p