C和C++程序员面试秘笈③

本系列博客基于董山海的<C和C++程序员面试秘笈>，旨在记录，欢迎交流，可联系 zywang@shu.edu.cn !

---

第三章：引用和指针

---

1、面试题1

一般变量引用

#include <iostream>
#include <string>
using namespace std;

int main(int argc, char* argv[]) {
	int a = 10, b = 20;
	int &rn = a;	//声明 rn 是变量 a 的一个引用，也就是 rn 是 a 的一个别名
	int equal;
	//
	rn = b;
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	//
	rn = 100;
	//
	cout << "a =" << a << endl;
	cout << "b =" << b << endl;
	//
	equal = (&a == &rn) ? 1 : 0;
	cout << "equal = " << equal << endl;

	system("pause");
	return 0;
}

2、面试题2

指针变量引用
引用类型的变量在声明的同时必须初始化

#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
	int a = 1;
	int b = 10;
	int *p = &a;	//这一行的意思是声明整型的指针变量P，并指向a，也就是p指向a
	int*  &pa = p;  //声明p的一个指针引用pa
	(*pa)++;	//将引用里面的值加1
	pa = &b;	//将pa指向变量b的地址，由于pa也是p的引用，此时p也指向了b
	(*pa)++;

	return 0;
}

3、面试题3

交换两个字符串

#include <iostream>
#include <string>

//利用传指针引用实现字符串交换
void swap(char *&x, char *&y) {
	char *temp;
	temp = x;
	x = y;
	y = temp;
 }

4、面试题4

指针和引用的区别

1. 初始化要求不同：引用在创建的同时必须初始化，即引用到一个有效的对象；而指针在定义的时候不必初始化，可以在定义后面的任何地方重新赋值；
2. 可修改性不同。引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用；而指针在任何时候都可以改变为指向另一个对象；
3. 不存在NULL引用，引用不能使用空值的引用，而指针可以是NULL；

引用比传指针安全的原因：
1、 引用一旦初始化指向一个对象，不能再改变了；
2、 指针随时指向别的对象，并且可以不被初始化，或为NULL。

5、面试题5

复杂指针的声明

int a;	//定义一个整数
int *a;	//一个指向整数型的指针
int **a;  //一个指向指针的指针，它指向的指针的指针指向一个整型数的
int a[10];	//定义一个整数型的数组
int *a[10];		//一个有10个指针的数组，该指针指向整数
int(*a)[10];	//一个指向有10个整型数数组的指针
int(*a)(int);	//一个指向函数的指针，该函数有一个整型参数并返回一个整型数
int(*a[10])(int);	//一个有10个的指针数组，该指针指向一个函数，函数有一个整型参数并返回一个整型数；

6、面试题6

复杂指针的阅读

1. 解读复杂指针声明：从未定义的标识符开始阅读，而不是从括号开始阅读；
2. 如：$int(\ast func)(int\ast p)$ 表示：未定义的标识符为 $func$，左边为一个*号，说明 $func$ 是一个指针；跳出圆括号，先看右边，也是一个圆括号，这时候 $(\ast func)$ 是一个函数，而 $func$ 是指向这个函数的指针，也就是函数指针，这个函数的形参是 $int\ast$ 类型，返回值为 $int$ 类型。
3. $int(\ast func)(int\ast p,int(\ast f)(int\ast ))$：$func$ 是一个指向函数的指针，该指针函数的形参为：$int\ast$ 和 $int(\ast )(int\ast )$，返回值为$int$ 类型。再看看 $func$ 的形参$int(\ast f)(int\ast )$，这表示$f$也是一个函数指针；
4. $int(\ast func[5])(int\ast p)$：$func$ 是一个具有5个元素的数组，且元素为指针，形参为：$int\ast p$；
5. $int(\ast (\ast func)[5])(int\ast p)$：$func$ 为一个指针，指向数组的指针，数组的元素是指向指针；
6. $int(\ast (\ast func)(int\ast p))[5]$：$func$ 是一个函数指针，这类函数具有 $int\ast$ 类型的形参，返回值是指向数组的指针，所指向的数组元素具有5个int元素的数组；

7、面试题7

指针加减操作
对指针$+1$表示：得到下一个元素的地址，而不是原有的地址值直接加1。所以对一个类型为 t 的指针的移动，以 sizeof(t) 为移动单位。

#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;

int main() {
	int a[5] = { 1,2,3,4,5 };	//声明一个一维数组
	int *ptr = (int *)(&a + 1);		//这边注意的是（a+1）和（&a+1）的地址不一样，&a+1表示下一个对象的地址
	//
	printf("%d\n", *(a + 1));
	printf("%d\n", *(ptr-1));
	system("pause");
	return 0;
}

8、面试题8

指针常量与常量指针的区别
常量指针：指向常量的指针，本身可以修改，指针所指向的内容是不容修改的；
指针常量：指针的常量，不可修改地址的指针，但是可以对它所指向的内容进行修改；

如果const位于*号的左侧，用const来修饰指针所指向的变量，即指针指向为常量；
如果const位于*号的右例，const修饰指针本身，即指针本身是常量；

//指针常量，不可修改地址的指针，但是可以对它所指向的内容进行修改
char * const p1;
//常量指针，地址不可被修改，内容可被修改
char const * p2;
//常量指针
const char *p3;
//常量，并且它指向的内容也不能修改
const char *constp4;

9、面试题9

this指针
类的非静态成员函数属于类的对象，只有他含有this指针；而类的static函数属于类本身，友元函数是非成员函数，不含this指针。

10、面试题10

指针数组：一个数组内存放的都为同一类型的指针；
数组指针：一个指针，指向一个数组的地址；
指针函数：返回指针类型的函数。带指针的函数，本质是一个函数，返回类型是某一类型的指针。定义如下：
$$返回类型标识符\ast 返回名称（形式参数表）函数体$$

#include <iostream>
using namespace std;

int max(int x, int y) {
	return (x > y ? x : y);
};

//函数find()被定义为指针函数，函数p被定义为函数指针类型
float *find(float *p, int x) {
	return p + x;
}

int main() {
	float score[] = { 10,20,30,40 };
	int(*p)(int, int);
	float *q = find(score + 1, 1);	//这边score为地址，返回的是地址
	int a;
	//
	p = max;	//p被赋值为max函数的地址
	a = (*p)(1, 2);
	//
	cout << "a = " << a << endl;
	cout << "*q = " << *q << endl;
	system("pause");
	
	return 0;
}

函数指针：指向函数地址的指针；

下面总结：

1. 含10个元素的指针数组：int *a[10]；

2. 数组指针：int *a= new int[10]；

3. 函数指针：void (*fn)(int，int)；fn是指向 void max(int x,int y)类型的函数指针；

4. 指向函数的指针数组: int (*fnArray[10])(int，int)；

5. const指针：const int *p；

6. 指向const的指针：int* const p；

7. 指向const的const指针：const int * const p；

11、面试题11

函数指针的使用：

#include <stdio.h>
#include <algorithm>
//
int add1(int a1, int b1);
int add2(int a2, int b2);
//
int main(int argc, char* argv[]) {
	int numa1 = 1, numb1 = 2;
	int numa2 = 2, numb2 = 3;
	int(*op[2])(int a, int b);	//定义了一个函数指针数组，含有两个指针元素
	op[0] = add1;
	op[1] = add2;
	printf("%d %d\n", op[0](numa1, numb1), op[1](numa2, numb2));
	getchar();

	system("pause");
	return 0;
}

int add1(int a1, int b1) {
	return a1 + b1;
}

int add2(int a2, int b2) {
	return a2 + b2;
}

12、面试题12

typedef用于函数指针的定义：

//定义了pfun类型，表示一个函数指针类型
typedef int(*pfun)(int x, int y);
//定义了一个函数
int fun(int x, int y);
//定义了一个pfun类型的函数指针p，并赋给它fun的地址
pfun p = fun;
int ret = p(2, 3);

13、面试题13

野指针：

野指针不是NULL指针，而是指向垃圾内存的指针。其成因主要为：指针变量没有初始化，或指针p被free或者delete之后，没有置为NULL。

14、面试题14

有了malloc/free，为什么还要new/delete？

前者是C++/C的标准库函数，后者为C++的运算符。它们都可以申请动态内存和释放内存！对于非内部数据类型的对象而言，只能用new/delete。

15、面试题15

有了malloc/free，为什么还要new/delete？

前者是C++/C的标准库函数，后者为C++的运算符。它们都可以申请动态内存和释放内存！对于非内部数据类型的对象而言，只能用new/delete。

16、面试题16

各种内存分配和释放的函数的联系和区别
C语言的标准内存分配函数：malloc、calloc、realloc、free等。

malloc与calloc的区别：1块与n块的区别；

malloc的调用形式为：（类型）malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址，此时内存中值没有初始化，是个随机数*；

calloc的调用形式为：（类型） calloc(n,size)：在内存的动态存储区分配n块长度为"size"字节的连续区域，返回首地址，此时内存中的值都被初始化为0*；

realloc的调用形式为：（类型）realloc(ptr,size)：将ptr内存大小增大到size，新增加的内存块没有初始化；

*free的调用形式为：free(void ptr)：释放ptr所指向的一块内存空间；

17、面试题17

内存分配方式有几种？

1. 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在，例如全局变量；
2. 在栈上创建。执行函数的时候，局部变量的存储单元可以在栈上创建，执行结束后这些单元自动被释放；
3. 在堆上分配，也叫动态内存分配。程序在运行的时候用malloc或者new申请任意多少的内存，并且自己负责free或者delete。

18、面试题18

什么是句柄？

句柄是来标识项目的，例如：module、task、instance、file、block of memory、menu、control、front、resource、GDI对象等。

在windows编程中会用到大量的句柄，比如HINSTANCE（实例句柄）、HBITMAP（位图句柄）、HDC（设备描述表句柄）、HICON（图标句柄）,还有一个通用的句柄，就是HANDLE。

句柄地址（稳定）->记载着对象在内存中的地址->对象在内存中的地址（不稳定）->实际对象。

指针与句柄的区别：
指针：对应着一个数据在内存中的地址，得到指针之后可以自由的修改该数据。而句柄是一个指向指针的指针。句柄和指针都是地址，不同之处在于：

1. 句柄所指的可以是一个很复杂的结构，并且很可能与系统有关的。比如说线程的句柄，这个十分常见。线程的句柄指向一个类或者结构，它和系统有着很密切的关系。当一个线程由于不可预料的原因而终止是，系统就可以返回它所占用的资料，如GPU、内存等。句柄中的某一项是与系统进行交互。
2. 指针也可以指向一个复杂的结构，但需要用户自己定义，所需要的工作用户自己完成，特别是删除的时候。