🙋 继续C++ Primer 第五版的学习

可以先看看这两篇 或许可以进一步加深一下对指针的理解

指针和数组

指针简介

🌈 上一次讲了 C++中的引用，总结一下指针和引用的主要区别。

1⃣ 指针是一个变量，其存储的是另一个变量的地址。而引用是一个别名，它和被它引用的变量共享同一内存地址。

2⃣指针可以被赋予空值（即NULL），而引用必须在定义时初始化，并且不能被赋予空值。

3⃣对指针的操作不会影响其指向的变量，除非通过指针进行赋值或解引。而对引用的操作会影响其引用的变量。

🌞下面就开始指针的学习叭~

指针

指针(pointer）是“指向（point to)”另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的间接访问。然而指针与引用相比又有很多不同点。

其一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象。

其二，指针无须在定义时赋初值。和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值。

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

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

获取对象的地址

指针存放某个对象的地址，要想获取该地址，需要使用取地址符（操作符&):

1
2
int ival = 42;
int *p = &ival; //p存放变量ival的地址，或者说p是指向变量ival的指针

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

一般而言，所有指针的类型都要和它所指向的对象严格匹配。

1
2
3
4
5
6
7
double dval;
double *pd = &dval;//正确:初始值是double型对象的地址
double *pd2 = pd; //正确:初始值是指向 double对象的指针
int *pi = pd;
//错误:指针pi的类型和pd的类型不匹配
pi = &dval;
//错误:试图把double型对象的地址赋给int型指针

因为在声明语句中指针的类型实际上被用于指定它所指向对象的类型，所以二者必须匹配。如果指针指向了一个其他类型的对象，对该对象的操作将发生错误。

指针的值

指针的值（即地址）应属下列4种状态之一:

1．指向一个对象。

2．指向紧邻对象所占空间的下一个位置。

3．空指针，意味着指针没有指向任何对象。

4．无效指针，也就是上述情况之外的其他值。

试图拷贝或以其他方式访问无效指针的值都将引发错误。编译器并不负责检查此类错误，这一点和试图使用未经初始化的变量是一样的。访问无效指针的后果无法预计，因此程序员必须清楚任意给定的指针是否有效。

尽管第2种和第3种形式的指针是有效的，但其使用同样受到限制。显然这些指针没有指向任何具体对象，所以试图访问此类指针（假定的）对象的行为不被允许。如果这样做了，后果也无法预计。

利用指针访问对象

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

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

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

1
2
3
*p = 0;
//由符号*得到指针p所指的对象，即可经由p为变量ival赋值
cout<<*p;//输出0

如上述程序所示，为*p赋值实际上是为p所指的对象赋值。解引用操作仅适用于那些确实指向了某个对象的有效指针。

关键概念:某些符号有多重含义

像&和*这样的符号,既能用作表达式里的运算符,也能作为声明的一部分出现,符号的上下文决定了符号的意义:

1
2
3
4
5
6
int i= 42;
int &r =i;//&紧随类型名出现，因此走声明的一部分，r是一个引用
int *p;//*紧随类型名出现，因此是声明的一部分,p是一个指针
p = &i;//&出现在表达式中，是一个取地址符
*p= i;//*出现在表达式中，是一个解引用符
int &r2= *p;//&是声明的一部分，*是一个解引用符

在声明语句中,&和*用于组成复合类型;在表达式中,它们的角色又转变成运算符。在不同场景下出现的虽然是同一个符号,但是由于含义截然不同,所以我们完全可以把它当作不同的符号来看待。

空指针

空指针（null pointer）不指向任何对象，在试图使用个指针之前代码可以首先检查它是否为空。以下列出几个生成空指针的方法:

1
2
3
4
5
6
7
8
int *pl = nullptr;
//等价于int *pl = 0;
int *p2 =0;
//直接将p2初始化为字面常量0
//需要首先#include cstdlib
int *p3 = NULL;
//等价于int *p3 = 0;

得到空指针最直接的办法就是用字面值nullptr来初始化指针，这也是CH+11新标准刚刚引入的一种方法。nullptr是一种特殊类型的字面值，它可以被转换成(参见2.1.2节，第32页)任意其他的指针类型。另一种办法就如对p2的定义一样，也可以通过将指针初始化为字面值0来生成空指针。

过去的程序还会用到一个名为NULL 的预处理变量(preprocessor variable）来给指针赋值,这个变量在头文件cstdlib中定义，它的值就是0。

2.6.3节（第68页）将稍微介绍一点关于预处理器的知识，现在只要知道预处理器是运行于编译过程之前的一段程序就可以了。预处理变量不属于命名空间std，它由预处理器负责管理，因此我们可以直接使用预处理变量而无须在前面加上std : :

当用到一个预处理变量时，预处理器会自动地将它替换为实际值，因此用NUL初始化指针和用0初始化指针是一样的。在新标准下，现在的C++程序最好使用nullptr，同时尽量避免使用NULL。

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

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

初始化指针

使用未经初始化的指针是引发运行时错误的一大原因。和其他变量一样，访问未经初始化的指针所引发的后果也是无法预计的。通常这一行为将造成程序崩溃,而且一旦崩溃，要想定位到出错位置将是特别棘手的问题。

在大多数编译器环境下,如果使用了未经初始化的指针,则该指针所占内存空间的当前内容将被看作一个地址值。访问该指针,相当于去访问一个本不存在的位置上的本不存在的对象。糟糕的是,如果指针所占内存空间中恰好有内容，而这些内容又被当作了某个地址，我们就很难分清它到底是合法的还是非法的了。

因此建议初始化所有的指针，并且在可能的情况下,尽量等定义了对象之后再定义指向它的指针。如果实在不清楚指针应该指向何处,就把它初始化为nullptr或者0,这样程序就能检测并知道它没有指向任何具体的对象了。

赋值和指针

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

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

1
2
3
4
5
6
7
8
9
10
11
int i =42;
int *pi = 0;
//pi被初始化，但没有指向任何对象
int *pi2 = &i;
//pi2被初始化，存有i的地址
int *pi3;
//如果pi3定义于块内，则pi3的值是无法确定的
pi3 = pi2;
// pi3和pi2指向同一个对象i
pi2 = 0;
//现在pi2不指向任何对象了

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

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

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

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

则* pi（也就是指针pi指向的那个对象）发生改变。

其他指针操作

只要指针拥有一个合法值,就能将它用在条件表达式中。和采用算术值作为条件（参见2.1.2节，第32页）遵循的规则类似，如果指针的值是0,条件取false:

1
2
3
4
5
6
7
int ival = 1024;
int *pi = 0;// pi合法，是一个空指针
int *pi2 = &ival;// pi2是一个合法的指针存放着ival的地址
if (pi)//pi的值是0，因此条件的值是false
    ...
if (pi2)// pi2指向ival，因此它的值不是0，条件的值是true

任何非0指针对应的条件值都是true。

对于两个类型相同的合法指针，可以用相等操作符(==）或不相等操作符(!=）来比较它们，比较的结果是布尔类型。如果两个指针存放的地址值相同，则它们相等;反之它们不相等。这里两个指针存放的地址值相同(两个指针相等）有三种可能:它们都为空、都指向同一个对象，或者都指向了同一个对象的下一地址。

需要注意的是，一个指针指向某对象，同时另一个指针指向另外对象的下一地址，此时也有可能出现这两个指针值相同的情况，即指针相等。

因为上述操作要用到指针的值，所以不论是作为条件出现还是参与比较运算，都必须使用合法指针，使用非法指针作为条件或进行比较都会引发不可预计的后果。

3.5.3节（第105页）将介绍更多关于指针的操作。

void* 指针

void是一种特殊的指针类型,可用于存放任意对象的地址。一个void 指针存放着一个地址，这一点和其他指针类似。不同的是，我们对该地址中到底是个什么类型的对象并不了解:

1
2
3
4
5
6
7
double obj= 3.14, *pd = &obj;
//正确:void*能存放任意类型对象的地址
void *pv = &obj;
// obj可以是任意类型的对象
pv = pd;
//pv可以存放任意类型的指针

利用void指针能做的事儿比较有限: 拿它和别的指针比较、作为函数的输入或输出，或者赋给另外一个 void 指针。**不能直接操作 void*指针所指的对象，因为我们并不知道这个对象到底是什么类型，也就无法确定能在这个对象上做哪些操作。**

概括说来，以void * 的视角来看内存空间也就仅仅是内存空间,没办法访问内存空间中所存的对象，关于这点将在19.1.1节（第726页）有更详细的介绍，4.11.3节（第144页)将讲述获取void*指针所存地址的方法。

练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//练习2.18:编写代码分别更改指针的值以及指针所指对象的值。
//练习2.19:说明指针和引用的主要区别。
//练习2.20:请叙述下面这段代码的作用。
int i = 42;
int *pl = &i;
*p1 = *p1 * *pl;
//练习2.21:请解释下述定义。在这些定义中有非法的吗?如果有，为什么?
int i = 0;
(a) double* dp = &i; (b)int *ip = i; (c) int *p = &i;
//练习2.22:假设p是一个int型指针，请说明下述代码的含义。
if (p)// ...
if(*p)// ...
//练习2.23:给定指针p，你能知道它是否指向了一个合法的对象吗?如果能，叙述判断的思路;如果不能，也请说明原因。
//练习2.24:在下面这段代码中为什么p合法而lp非法?
int i = 42;
void *p = &i;
long * lp = &i;

答案

答案🏮

1⃣练习2.18:编写代码分别更改指针的值以及指针所指对象的值。

1
2
3
4
5
6
7
8
9
int a = 10;
int *p = &a;
int *q = p;

// 更改指针的值
p = q; // 现在p和q指向相同的地址

// 更改指针所指对象的值
*p = 20; // 现在a的值变为20

2⃣练习2.19:说明指针和引用的主要区别。

  1. 指针是一个变量，其存储的是另一个变量的地址。而引用是一个别名，它和被它引用的变量共享同一内存地址。
  2. 指针可以被赋予空值（即NULL），而引用必须在定义时初始化，并且不能被赋予空值。
  3. 对指针的操作不会影响其指向的变量，除非通过指针进行赋值或解引。而对引用的操作会影响其引用的变量。

3⃣练习2.20:请叙述下面这段代码的作用。

1
2
3
int i = 42;
int *pl = &i;
*p1 = *p1 * *pl;

它首先定义了一个整型变量i并赋值为42，然后定义了一个指向i的指针pl。接着，它尝试通过p1修改p1所指向的变量的值，使其变为p1所指向的值与i值的乘积。

就是说 先定义并初始化了一个变量i，然后pl指向i，也就是pl就是i的值，即42，然后 pl= p1 pl; 于是 pl=42 42 ；又由于然后pl指向i，所以i此时也被更改为42 42

4⃣练习2.21:请解释下述定义。在这些定义中有非法的吗?如果有，为什么?

1
2
int i = 0;
(a) double* dp = &i; (b)int *ip = i; (c) int *p = &i;

  1. 非法。因为i是整型变量，而double类型和整型不兼容。

  2. 非法。因为i是一个整型变量，不能直接作为指针赋值。

  3. 合法

5⃣练习2.22:假设p是一个int型指针，请说明下述代码的含义。

1
2
if (p)// ...
if(*p)// ...
  • if(p) 检查p是否不为NULL，即p是否指向了一个有效的内存地址。
  • if(*p) 检查p所指向的内存地址的内容是否不为零（或其他非真值）。

6⃣练习2.23:给定指针p，你能知道它是否指向了一个合法的对象吗?如果能，叙述判断的思路;如果不能，也请说明原因。

不能。判断指针是否指向一个合法的对象，需要检查指针是否为NULL，以及它所指向的地址是否有效。然而，这并不总是安全的，因为指针可能指向一个有效的地址，但该地址的内容可能是不合法的或者已经被释放。

所以不论是作为条件出现还是参与比较运算，都必须使用合法指针，使用非法指针作为条件或进行比较都会引发不可预计的后果。

7⃣练习2.24:在下面这段代码中为什么p合法而lp非法?

1
2
3
int i = 42;
void *p = &i;
long * lp = &i;

void* 是一种特殊的指针类型,可用于存放任意对象的地址。一个void * 指针存放着一个地址。在这段代码中，p是合法的，因为它被初始化为指向i的地址，这是一个有效的整型地址。

lp是非法的，因为int和long类型不兼容。虽然lp被赋予了i的地址，但这个地址对于long类型的数据是不正确的，因此这种用法是非法的。