原创 C/C++复习之路——王道程序员求职宝典——第七章《指针与引用》

谁借莪１个温暖的怀抱￠ 2023-03-02 07:45 12阅读 0赞

### 文章目录 ###

*   *  函数指针
     *   *  函数指针简化
         *  函数指针应用
         *  返回指向函数的指针
     *  引用
     *   *  const引用
         *  引用做类的数据成员

例。在32位系统下，写出下属代码的输出结果。

int main(){ 
    	double* (*a)[3][6];
    	cout<<sizeof(a)<<endl;
    	cout<<sizeof(*a)<<endl;
    	cout<<sizeof(**a)<<endl;
    	cout<<sizeof(***a)<<endl;
    	cout<<sizeof(****a)<<endl;
    }

解析：a是一个数组指针，指向一个数组。这个数组是一个3行6列的二维数组，且这个数组的元素类型为double\*。故a的类型为double\*(\*)\[3\]\[6\]。  
  cout<<sizeof(a)<<endl; 输出为4，因为a为指针；  
  cout<<sizeof(\*a)<<endl; 输出为72，因此\*a为一个3行6列的数组，且元素类型为double\*，故占用内存3*6*4=72；  
  cout<<sizeof(\*\*a)<<endl; 输出为24，\*a为一个3行6列的数组，故**a为此数组首元素\*a\[0\]，\*a\[0\]也是一个数组，且为一维数组，长度为6，元素类型为double\*，故**a占用内存大小为6\*4=24；  
  cout<<sizeof(\*\*\*a)<<endl; 输出为4，因为\*\*a是一个一维数组，长度为6，元素类型为double\*，故\*\*\*a是一维数组的一个元素，类型为double\*，故\*\*\*a占用内存大小为4。  
  cout<<sizeof(\*\*\*\*a)<<endl; 输出为8，因为\*\*\*a是一维数组的一个元素，类型为double\*，故\*\*\*\*a类型为double，占用内存大小为8。

## 函数指针 ##

函数指针是指向函数而非指向对象的指针。函数指针也指向某个特定的函数类型，函数类型由其返回类型以及形参表确定，而于函数名无关。例如：

bool (*pf) (const string &, const string &);

**注意**：\*pf两边的小括号是必须有的

### 函数指针简化 ###

函数指针类型相当冗长，因此可以使用typedef为指针类型定义同义词，可以将函数指针的使用大大简化：

typedef bool (*cmpFcn) (const string &, const string &);

该定义表示cmpFun是一种指向函数的指针类型的名字。该指针类型为“指向返回bool类型并带有两个const string引用形参的函数的指针”。在使用这种函数指针类型时，只需直接使用cmpFun即可，不必每次都把整个类型声明全部写出来。

在引用函数名但又没有调用该函数时，函数名将被自动解释为指向函数的指针。假设有函数：

bool lengthCompare(const string &, const string &);

除了用做函数调用的左操作数以外，对lengthCompare的任何使用都被解释为如下类型的指针：

bool (*) (const string &, const string &);

可以使用函数名对函数指针做初始化或赋值，其中cmpFcn已经在上文中定义：

cmpFcn pf1=0;	//ok，未绑定函数的指针
    cmpFcn pf2=lengthCompare;	//ok，指针类型和函数类型匹配
    pf1 = lengthCompare;	//ok，指针类型和函数类型匹配
    pf2 = pf1;	//ok，指针类型匹配

此时，直接饮用函数名等效于在函数名上应用取地址符号：

cmpFcn pf1=lengthCompare；
    cmpFcn pf1=&lengthCompare；

函数指针只能通过同类型的函数或函数指针或0值常量表达式进行初始化或赋值。将函数指针初始化为0，表示该指针不指向任何函数。

### 函数指针应用 ###

指向函数的指针可以用于调用它所指向的函数。可以不需要使用解引用操作符，直接通过指针调用函数，则有：

typedef bool (*cmpFcn) (const string &, const string &);
    bool lengthCompare(const string &, const string &);

则：

cmpFcn pf=lengthCompare;
    lengthCompare("hi", "bye");	//语句1

语句1位直接调用lengthConpare函数；

pf("hi", "bye");	//语句2

语句2零函数指针调用lengthConpare函数，未使用\*；

(*pf) ("hi", "bye");	//语句3

语句3利用函数指针调用lengthConpare函数，使用\*；

### 返回指向函数的指针 ###

函数可以返回指向函数的指针：

int (*ff(int)) (int*, int);

阅读函数指针声明的最佳方法是从声明的名字开始由里而外理解。首先`ff(int)`将ff声明为一个函数，它带有一个int型的参数。该函数返回`int (*)(int*, int);`。  
例、

typedef int func(int*, int);	//func是一个函数，而不是一个函数指针
    void f1(func);	//正确，f1的形参是一个函数指针，func自动转换为函数指针
    func f2(int);	//错误，func无法自动被转换
    func *f3(int);	//正确，f3返回一个函数指针

例。定义一个函数指针，指向的函数有两个int形参，并返回一个函数指针，返回的函数指针指向一个有一个int形参且返回int的函数，下列正确的是（）。

*  A. int (\*(\*F) (int, int)) (int)
 *  B. int (\*F) (int, int)
 *  C. int (\*(\*F) (int ,int))
 *  D. \*(\*F) (int, int) (int)

解析：A。

## 引用 ##

C++中规定一旦定义了引用，就必须把它跟一个变量绑定起来，并且不能修改这个绑定。  
  虽然使用引用和指针都可以间接访问另一个值，但它们之间有几个重要区别：

*  引用不能为空，当引用被创建时，必须被初始化。而指针可以为空值，可以在任何时候被初始化；
 *  一单一个引用被初始化为指向一个对象，他就不能被改变为对另外一个对象的引用。指针则可以在任何时候指向另一个对象。
 *  不可能有NULL引用。必须保证引用是一块合法的存储单元关联；
 *  “sizeof(引用)”所得到的的是指向的变量（对象）的大小，而“sizeof(指针)”得到的是之真本身的大小，通常为4；
 *  给引用赋值修改的是该引用所关联的对象的值，而并不是使用引用于另一个对象关联；
 *  引用使用时不需要解引用，而指针需要解引用，引用和指针的自增（++）操作运算符意义不一样；
 *  如果返回动态分派的对象或内存，必须使用指针，引用可能引起内存泄漏；
 *  当使用&运算符去一个引用的地址时，其值为所引用变量的地址；而对指针使用&运算符，区的是指针变量的地址。

例。下列代码的输出结果是什么？

int i=3,j=1;
    int &ref=i;
    cout<<ref;	//输出3
    ref=k;	//注意这里将i修改为1，而不是修改ref时期绑定到j上
    cout<<ref;	//输出1
    cout<<i;	//输出1

### const引用 ###

const引用是指const对象的引用，当引用的对象是const对象时，引用也必须是const，如下：

const int ival=1024;
    const int &ref1=ival;	//正确
    int &ref2=ival;		//错误

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不再函数中被改变，就应该使用常引用。常饮用主要用于定义一个普通变量的只读属性的别名，作为函数的传入形参，避免实参在调用函数中被意外改变。

### 引用做类的数据成员 ###

引用是可以作为类的数据成员的。  
  引用类型数据成员的初始化有以下特点：

*  不能直接在构造函数里初始化，必须用到初始化列表；
 *  反思有引用类型的数据成员的类，必须定义构造函数。  
    如下：
    
        class ConstRef{ 
        public:
        	ConstRef(int ii):i(ii), ci(i), ri(ii) { }	//ci与ri必须在成员初始化列表中初始化，因此必须自定义构造函数，书写成员初始化列表
        Private:
        	int i;
        	const int ci;
        	int &ri;
        };

例。下面程序的输出结果为（）。

char *c[] = { "ENTER", "NEW", "POINT", "FIRST"};
    char **cp[] = { c+3, c+2, c+1, c};
    char ***cp=cpp;
    int main(){ 
    	printf("%s", **++cpp);	//语句1
    	printf("%s", *--*++cpp+3);	//语句2
    	printf("%s", *cpp[-2]+3);	//语句3
    	printf("%s\n", *cpp[-1][-1]+1);	//语句4
    	return 0;
    }

解析：第一个是POINT，第二个是ER，第三是ST，第四个是EW。由题意可知，c是一个数组，它的元素类型是char\*，cp也是一个数组，它的元素类型是char\*\*（指向char\*的指针），且cp的每个元素指向c的一个元素，对应关系如下表所示

<table> 
 <thead> 
  <tr> 
   <th>ENTER</th> 
   <th>NEW</th> 
   <th>POINT</th> 
   <th>FIRST</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>c[0]</td> 
   <td>c[1]</td> 
   <td>c[2]</td> 
   <td>c[3]</td> 
  </tr> 
  <tr> 
   <td>cp[3]</td> 
   <td>cp[2]</td> 
   <td>cp[1]</td> 
   <td>cp[0]</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td>cpp</td> 
  </tr> 
 </tbody> 
</table>

语句1：cpp为一个指向char\*\*的指针，故其初始化为cp，而cp是一个指针数组，数组里面存储的类型为char\*\*，也即cpp指向cp\[0\]，故\*cpp=cp\[0\]。++p使得cpp指向cp\[1\]，故\*++cpp=cp\[1\]。因此语句1中\*\*++cp=\*cp\[1\]=c\[2\]，输出为POINT。  
  语句2：此时cpp指向cp\[2\]，如下图所示：

<table> 
 <thead> 
  <tr> 
   <th>ENTER</th> 
   <th>NEW</th> 
   <th>POINT</th> 
   <th>FIRST</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>c[0]</td> 
   <td>c[1]</td> 
   <td>c[2]</td> 
   <td>c[3]</td> 
  </tr> 
  <tr> 
   <td>cp[3]</td> 
   <td>cp[2]</td> 
   <td>cp[1]</td> 
   <td>cp[0]</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>cpp</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

首先，++cpp使得cpp指向cp\[2\]，然后\*++cpp即为cp\[2\]，故：  
语句2中–\*++cpp=–cp\[2\]，此时cp\[2\]指向c\[1\]，对一个指针–，即使得cp\[2\]指向c\[0\]。则\*–\*++cpp+3=\*–cp\[2\]+3=c\[0\]+3，输出为ER。  
  语句3：此时表格变为：

<table> 
 <thead> 
  <tr> 
   <th>ENTER</th> 
   <th>NEW</th> 
   <th>POINT</th> 
   <th>FIRST</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>c[0]</td> 
   <td>c[1]</td> 
   <td>c[2]</td> 
   <td>c[3]</td> 
  </tr> 
  <tr> 
   <td>cp[3]/cp[2]</td> 
   <td></td> 
   <td>cp[1]</td> 
   <td>cp[0]</td> 
  </tr> 
  <tr> 
   <td>cpp</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

语句3中\*cpp\[-2\]+3=\*(\*(cpp-2))+3，因此cpp指向cp\[2\]，则（cpp-2）指向cp\[0\]，\*(cpp=2)=cp\[0\]，则\*\*(cpp-2)=c\[3\]，则语句3中\*cpp\[-2\]+3=\*(\*(cpp-2))+3=c\[3\]+3，输出为ST。  
语句4：cpp\[-1\]\[-1\]=\*(\*(cpp-1)-1)+1=c\[1\]+1，输出为EW。

野指针：

*  野指针是指向不可用内存的指针，任何指针变量在创建时，不会自动成为NULL指针（空指针），其默认值是随机的，此时的指针就是野指针。
 *  当指针调用free或者delete释放后，未能将其设置为NULL，也会导致该指针便成为野指针，此时虽然free或delete吧指针所指的内存释放掉了，但它们并没有把指针本身释放掉。
 *  第三个造成野指针的原因是指针操作超越了变量的作用范围。