学习笔记——引用和指针

引用

        引用为对象起了另外一个名字。

        通过将声明符写成&d的形式来定义引用类型，其中d是声明的变量名；

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

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

静态类型：对象在声明时使用的类型，在编译期就已经确定
动态类型：指针变量或引用变量所指向对象的类型，在运行期才能确定
静态绑定：绑定的是静态类型，对象的函数和属性依赖于绑定的静态类型，发生在编译期
动态绑定：绑定的是动态类型，对象的函数和属性依赖于绑定的动态类型，发生在运行期
一般来说，而非虚函数都是静态绑定，虚函数则是动态绑定。

引用即别名 

引用并非对象，相反的，它只是一个为已经存在的对象所起的另外一个名字

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

refVal = 2;         // 把2赋给refVal指向的对象，此处即是赋给了ival
int ii = refVal;    // 与ii = ival 执行结果一样

        为引用赋值，实际上是把值赋给了与引用绑定的对象。获取引用的值，实际上是获取了与引用绑定的对象的值。同理，以引用作为初始值，实际上是以与引用绑定的对象作为初始值：

// 正确：refVal3绑定到了那个与refVal绑定的对象上，这里就是绑定到ival上
int &refVal3 = refVal;
// 利用与refVal绑定的对象的值初始化变量i
int i = refVal;    // 正确：i能狗给正确初始化为ival的值

因为引用本身不是一个对象，所以不能定义引用的引用

引用的定义

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

        

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型对象

指针

        指针是“指向”，是另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的间接访问。与引用的不同点如下：其一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象。其二，指针无须再定义时赋初值。

        定义指针类型的方法将声明符写成*d的形式，其中d是变量名。如果在一条语句中定义了几个指针变量，每个变量前面都必须有符号*

int *ip1, *ip2;    //ip1和ip2都是指向int型对象的指针
double dp, *dp2;   //dp2是指向double型对象的指针，dp是double型对象

获取对象的地址

        指针存放某个对象的地址，要想获取该地址，需要使用取地址符号（&）：

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;        // 由符号*得到指针p所指的对象，即可经由p为变量ival赋值
cout << *p;    // 输出0

        如上，为*p赋值实际上是为p所指的对象（ival）赋值

只有在声明指针和引用时（紧随类型名出现），*和&才作为指针和引用的作用出现，在其他的表达式中，它们的作用均是解引用符和取地址符

int &r2 = *p;    //&是声明的一部分，声明r2是一个引用，*是解引用符，代表取指针p指向对象的内容

解引用操作仅适用于那些确实指向了某个对象的有效指针

空指针 

        空指针不指向任何对象，在试图使用一个指针之前可以首先检查它是否为空。

int *p1 = nullptr;    //等价于int *p1 = 0;
int *p2 = 0;          //直接将p2初始化为字面常量0
//需要首先#include cstdlib
int *p3 = NULL;       //等价于int *p3 = 0;

        得到空指针最直接的方法就是用字面值nullptr来初始化指针。nullptr是一种特殊类型的字面值，它可以被转换成任意其他的指针类型（NULL则需要强制转换，如(void*)NULL，因为NULL经过预处理后实际上等于0，会被处理成整数类型，而nullptr为空指针常量，是指针类型）

我们可以将指针明确指向 0（0x0000 0000）这个内存空间。一方面，明确指针的指向可以避免其成为野指针；另一方面，大多数操作系统都不允许用户对地址为 0 的内存空间执行写操作，若用户在程序中尝试修改其内容，则程序运行会直接报错。因此该内存空间可以等价于空（用户无法在此空间中做修改）

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

int zero = 0;
pi = zero;        // 错误：不能把int变量直接赋给指针

 指针一定要进行初始化，不然在访问未初始化的指针时可能会引发无法预计的错误（野指针）

赋值和指针

        指针和引用都能提供对其他对象的间接访问，最主要的区别如下：

        引用本身并非一个对象，一旦定义了引用，就无法令其再绑定到另外的对象

        指针没有此限制，和其他变量一样，给指针赋值就是令它存放一个新的地址，从而指向一个新的对象。

        辨别一条赋值语句是改变指针的值还是指针所指对象的值的方法：记住赋值永远改变的是等号左侧的对象。

pi = &ival;     // pi的值被改变（指针），现在pi指向了ival
*pi = 0;    // *pi的值被改变（指针所指的对象），pi的值没有改变（指针）

void* 指针

        void*是一种特殊的指针类型，可用于存放任意对象的地址。一个void*指针存放着一个地址，这一点和其他指针类似。不能直接操作void*指针所指的对象，因为我们并不知道这个对象到底是什么类型，也就无法确定能在这个对象上做哪些操作。

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

malloc返回的就是void*类型的指针，因此需要通过类型转换来使用，例如(int*)malloc(sizeof(int))等等