【C++基础入门】指针

逃离我推掉我的手 2024-03-26 18:01 48阅读 0赞

## 一：指针 ##

指针，是C/C++语言中的一个重要概念及其特点，也是掌握C语言比较困难的部分。**指针也就是内存地址**，指针变量是用来存放内存地址的变量。指针使得 C 语言能够更高效地实现对计算机底层硬件的操作，而计算机硬件的操作很大程度上依赖地址，指针便提供了一种对地址操作的方法，在一定意义上，指针是c语言的精髓，所以一定要耐心看完。  
指针对于很多c语言初学者来说可能难以理解，一不小心可能被指针的指向关系绕进去，在这里就对指针做一些总结，写一下自己的理解。

### 1.1 指针的介绍 ###

在程序中，我们声明一个变量（int a = 1），将数据1存到变量a中，计算机内部会将这个数据存到内存（RAM）中，那么，数据存到某个地方，就会涉及地址。就像你买的快递，快递到了就要存到某个驿站里面放着，你的快递就是一个数据，驿站就是一个变量，这个驿站就要有地址，不然全国这么多驿站你怎么知道你的快递在哪个驿站。

到这里，地址的概念应该有了吧。

现在想想地址（比如0x0000 0001）不也是一个数据吗，那么不也可以用一个变量存地址这个数据？是的，可以，这个变量就是指针，指针它就是存储另一个变量的内存地址的一种数据类型，即指针的内容就是另一个变量的内存地址。

> 指针本身也是一个变量，所以指针变量也有自己的地址，只是它有点特殊，它存放的是另一个变量的地址而已，理解这句话就行。

前面讲到过指针它是一种数据类型，为了方便，我们就规定在这种类型后面加\*号表示该类型指针，有char型指针（char \*）、double型指针(double \*)和int型指针（int \*）等等。

试着敲一下下面一段代码，可以加深对指针的认识：

int a = 1;       // 定义一个int型变量
    int *p = &a;     // 定义一个int型指针p，&a表示对a取地址，指针p的内容是a的地址
    // int  *p;   p = &a;    // 第二行也可以这样写，意思一样
    printf("%p\n", &a);      // 打印a的地址
    printf("%p\n", p);       // 打印指针p指向的地址
    // %p是打印地址（指针地址），是十六进制的形式

C/C++ 中规定了 \* 操作符来从对应指针类型存放的地址中拿出相应数据，再定义一个变量int b = \*p，指针p存了a的地址，\*p就是拿出a的值，b的值就变成了1，\*操作也被称为解引用。

### 1.2 指针的相关操作（运算） ###

> 算数运算：+、-、++、–、

指针的运算是特别容易搞错的，千万不能以为和普通类型（比如int型数据）的运算一样。

**指针的加减运算：**  
指针+1/指针-1，加/减的是整个指针类型的长度，与其说指针的加减法，我认为不如说成指针的偏移更合适，接下来看为什么是偏移，举个非常明显的例子：

char a[5] = {
        1, 2, 3, 4, 5};  // 定义一个char型数组，这里的a实质上是一个指针，指向这个数组的首元素a[0]的指针
    char *p = a;
    printf("%d\n", *p);        // 输出1 --> a[0]
    printf("%d\n", *(p + 1));  // 输出2 --> a[1]
    ......

看输出的结果就很容易看出规律，p指针指向a\[0\]，特别注意p+1指针变成指向a\[1\]，所以\*(p+1) = a\[1\] = 2，而不是\*(p+1) = a\[0\] + 1 = 2，当然这里两个答案凑巧一样，但是把数组的内容换一下就不会是一样了，如果是改成(\*p) + 1，那么就是(\*p) + 1 = a\[0\] + 1 = 2，同理可以改成p+2、p+3…

还有试着定义其它类型的数组（比如int型：int a\[5\] = \{1, 2, 3, 4, 5\};），看看是不是这个规律，就可以知道指针加减的是这个指针类型的长度，也就是指针的偏移，还可以尝试定义结构体数组，将会有更深的理解。

减法就不用多说了，理解了指针p+1/p-1，那么指针p++/p–其实是一样的，都是偏移。

### 1.3 多级指针 ###

> 说起多级指针这个东西，曾经大一学c语言的时候，学到二级指针都已经把我给绕晕了，如果当时你给我写个int \*\*\*\*\*\*\*\*p出来，我估计直接崩溃到放弃。

我们先来说说二级指针吧！前面有讲到，指针也是一种数据类型，是一种变量，也有自己的地址，所以既然有地址，而指针就是存放另一个变量的地址的呀，那为什么不能再用一个指针存放这个指针的地址呢，对吧！所以就有了二级指针，就是指向指针的指针。

ok！来点生活上的东西，快递柜大家都用过吧，快递小哥给你发一个取件码你就能拿到快递。

![在这里插入图片描述][ec90dcd4c1fb4c90b62073f21b690aec.png]  
这里的每一个柜子就是一块内存，取件码就是地址，柜子里的快递就是存储在内存的内容/数据。

假如快递小哥把你的快递放到"058柜子"，给你发取件码，那么你输入取件码就可以取到快递。  
![在这里插入图片描述][7cb430446470432ba167f05bf119a35c.png]  
如果快递小哥逗你一下，故意给你发"057柜子"的取件码，然后在"057柜子"放一张纸条，上面写:快递在058柜子，这时候你肯定是按照纸条从"058柜子"里就可以拿到快递。

这里的"057柜子"就是指针，指针里面存放另一个变量（058柜子）的地址。  
![在这里插入图片描述][d991430fa29d411a87c6ad72a69d5f0d.png]  
如果快递小哥给你发"056柜子"的取件码，在"056柜子"里放一张纸条写：快递在"057柜子"里，又在"057柜子"里放一张纸条写：快递在"058柜子"里。

这里的"056柜子"就是二级指针，"057柜子"就是指针，"058柜子"就是指针存放的另一个变量。  
![在这里插入图片描述][c7af8257e3f04b28b37f4f369184fae4.png]  
现在明白了二级指针吧，那么，N级指针也就那样，也就是指向指针的指针的指针的指针的指针…，是不是非常简单！

int a = 1;
    int *p = &a;
    int **pp = &p;     // 二级指针pp存放指针p的地址，即二级指针pp指向指针p
    int ***ppp = &pp;  // 三级指针ppp存放二级指针pp的地址，即三级指针ppp指向二级指针pp
    ......

总之，如果一个内存如果存放的是另一个变量的地址，那么就叫指针。一块内存要么存放实际内容/数据，要么存放的是另一个变量的地址，确实是刚刚所说的非常简单。

【总结两点】：
    
     1. 指针本身也是一个变量，也有自己的地址，需要内存存储。 
    
     2. 指针存放的是所指向的变量的地址，这个所指向的变量也可以是一个指针。
    
    【特别注意】：面试可能被问到指针的大小
    
     1. 指针的大小跟指针是什么类型的没有任何关系。
    
     2. 在32为系统系统中，所有的指针大小都是4个字节，原因是32系统上所有变量的地址都是32位的，而指针用来存地址的。

最后，大家要明白一个概念，其实并没有什么多级指针这种东西，多级指针就是个指针，称为多级指针是为了我们方便表达而取的逻辑名称。

### 1.4 多维数组 ###

> 二维数组其实和二级指针有着相似的理解方法：  
> 比如a\[3\]\[2\]，把它理解成一个一维数组来看待，这个一维数组里面有三个元素，只是这个一维数组有点特殊，它的每个元素又是一个一维数组而已。

懂了上面这段话，二维数组就很好理解。

前面我们已经知道一维数组a\[3\]中，a实质上是一个指针，指向这个数组首元素a\[0\]：

int a[3] = {
        1, 2, 3};
    // a[0]  -->  *a
    printf("%d\n", *a);       // 打印 1  -->  a[0] 的值
    // a[1]  -->  *(a + 1)
    printf("%d\n", *(a + 1)); // 打印 2  -->  a[1] 的值
    // a[2]  -->  *(a + 2)
    printf("%d\n", *(a + 2)); // 打印 3  -->  a[2] 的值

那么，二维数组a\[3\]\[2\]当成一维数组看是不是可以得出：

int a[3][2] = {
        {
        1, 2}, {
        3, 4}, {
        5, 6}};
    // a[0][0]  -->  (*a)[0]
    printf("%d\n", (*a)[0]);       // 打印 1  -->  a[0][0] 的值
    // a[1][0]  -->  (*(a + 1))[0]
    printf("%d\n", (*(a + 1))[0]); // 打印 3  -->  a[1][0] 的值
    // a[2][0]  -->  (*(a + 2))[0]
    printf("%d\n", (*(a + 2))[0]); // 打印 5  -->  a[2][0] 的值
    // a[2][1]  -->  (*(a + 2))[1]
    printf("%d\n", (*(a + 2))[1]); // 打印 6  -->  a[2][1] 的值
    // ..... 二维数组其它元素类似都可以输出

结论一：a\[m\]\[n\] 等价于 （\*(a + m)\[n\] -->就是一个数组指针(后面会提到）  
基于前面两种指针和数组的变换，可以继续得出：

int a[3][2] = {
        {
        1, 2}, {
        3, 4}, {
        5, 6}};
    // a[0][0]  -->  (*a)[0]  -->  *(*a + 0)  -->  把 *a 当成整体
    printf("%d\n", *(*a));           // 打印 1  -->  a[0][0] 的值
    // a[1][0]  -->  (*(a + 1))[0]  -->  *(*(a + 1) + 0)
    printf("%d\n", *(*(a + 1)));     // 打印 3  -->  a[1][0] 的值
    // a[2][0]  -->  (*(a + 2))[0]  -->  *(*(a + 2) + 0)
    printf("%d\n", *(*(a + 2)));     // 打印 5  -->  a[2][0] 的值
    // a[2][1]  -->  (*(a + 2))[1]  -->  *(*(a + 2) + 1)
    printf("%d\n", *(*(a + 2) + 1)); // 打印 6  -->  a[2][1] 的值
    // ..... 二维数组其它元素类似都可以输出

结论二：a\[m\]\[n\] 等价于 *(*(a + m) + n)

### 1.5 数组指针与指针数组 ###

1.  数组指针：指针在后，说明它就是个指针，所以数组指针指向的是数组，相当于一次声明了一个指针。从前面就已经知道，二维数组a\[3\]\[2\]中，a实质上就是一个数组指针。

> 公式：指向的那个数组的元素类型 (\*指针名字)\[指向的数组的元素个数\]

1.  指针数组：数组在后，说明它就是个数组。字符数组是什么？就是存放字符的数组，那么指针数组就是存放指针类型的数组，相当于一次声明了多个指针。

> 公式：数组元素的类型 数组名字\[数组元素个数\]

char *a[3] = {
        "red", "green", "blue"};
    char **pp = a;    //定义二级指针pp, a本质上相当于二级指针
    printf("%s\n", pp[0]);    // 打印 red
    printf("%s\n", pp[1]);    // 打印 green
    printf("%s\n", pp[2]);    // 打印 blue

**直观上区分数组指针和指针数组的方法：**  
由于数组指针的 \[\] 比 \* 的优先级高，所以数组指针的指针加括号，所以看看指针有没有用圆括号括起来，就可以区分开。

### 1.6 其它 ###

关于指针想写的内容还有很多，其实这只是开了个头，比如：野指针、函数指针、函数参数传递方式、const 修饰指针、动态内存分配: malloc 和 free、堆, 栈、内存泄露…，以后再慢慢补齐。

指针在链表使用的比较多，多写一些链表的操作会对指针理解很有帮助，链表节点的增加、删除、修改、查找，单向链表、双向链表、双向循环链表、内核链表等等。

## 二：指针的代码介绍 ##

### 2.1 指针的基本概念 ###

**指针的作用：** 可以通过指针间接访问内存

*  内存编号是从0开始记录的，一般用十六进制数字表示
 *  可以利用指针变量保存地址

### 2.2 指针变量的定义和使用 ###

指针变量定义语法： `数据类型 * 变量名；`

**示例：**

int main() {
        
    
    	//1、指针的定义
    	int a = 10; //定义整型变量a
    	
    	//指针定义语法： 数据类型 * 变量名 ;
    	int * p;
    
    	//指针变量赋值
    	p = &a; //指针指向变量a的地址
    	cout << &a << endl; //打印数据a的地址
    	cout << p << endl;  //打印指针变量p
    
    	//2、指针的使用
    	//通过*操作指针变量指向的内存
    	cout << "*p = " << *p << endl;
    
    	system("pause");
    
    	return 0;
    }

指针变量和普通变量的区别

*  普通变量存放的是数据,指针变量存放的是地址
 *  指针变量可以通过" \* "操作符，操作指针变量指向的内存空间，这个过程称为解引用

> 总结1： 我们可以通过 & 符号 获取变量的地址

> 总结2：利用指针可以记录地址

> 总结3：对指针变量解引用，可以操作指针指向的内存

### 2.3 指针所占内存空间 ###

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

**示例：**

int main() {
        
    
    	int a = 10;
    
    	int * p;
    	p = &a; //指针指向数据a的地址
    
    	cout << *p << endl; //* 解引用
    	cout << sizeof(p) << endl;
    	cout << sizeof(char *) << endl;
    	cout << sizeof(float *) << endl;
    	cout << sizeof(double *) << endl;
    
    	system("pause");
    
    	return 0;
    }

> 总结：所有指针类型在32位操作系统下是4个字节

### 2.4 空指针和野指针 ###

**空指针**： 指针变量指向内存中编号为0的空间

**用途：** 初始化指针变量

**注意：** 空指针指向的内存是不可以访问的

**示例1：空指针**

int main() {
        
    
    	//指针变量p指向内存地址编号为0的空间
    	int * p = NULL;
    
    	//访问空指针报错 
    	//内存编号0 ~255为系统占用内存，不允许用户访问
    	cout << *p << endl;
    
    	system("pause");
    
    	return 0;
    }

**野指针**： 指针变量指向非法的内存空间

**示例2：野指针**

int main() {
        
    
    	//指针变量p指向内存地址编号为0x1100的空间
    	int * p = (int *)0x1100;
    
    	//访问野指针报错 
    	cout << *p << endl;
    
    	system("pause");
    
    	return 0;
    }

> 总结：空指针和野指针都不是我们申请的空间，因此不要访问。

### 2.5 const修饰指针 ###

const修饰指针有三种情况

1.  const修饰指针 — 常量指针
2.  const修饰常量 — 指针常量
3.  const即修饰指针，又修饰常量

**示例：**

int main() {
        
    
    	int a = 10;
    	int b = 10;
    
    	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    	const int * p1 = &a; 
    	p1 = &b; //正确
    	//*p1 = 100;  报错
    	
    
    	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    	int * const p2 = &a;
    	//p2 = &b; //错误
    	*p2 = 100; //正确
    
        //const既修饰指针又修饰常量
    	const int * const p3 = &a;
    	//p3 = &b; //错误
    	//*p3 = 100; //错误
    
    	system("pause");
    
    	return 0;
    }

> 技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

### 2.6 指针和数组 ###

**作用：** 利用指针访问数组中元素

**示例：**

int main() {
        
    
    	int arr[] = {
         1,2,3,4,5,6,7,8,9,10 };
    
    	int * p = arr;  //指向数组的指针
    
    	cout << "第一个元素： " << arr[0] << endl;
    	cout << "指针访问第一个元素： " << *p << endl;
    
    	for (int i = 0; i < 10; i++)
    	{
        
    		//利用指针遍历数组
    		cout << *p << endl;
    		p++;
    	}
    
    	system("pause");
    
    	return 0;
    }

### 2.7 指针和函数 ###

**作用：** 利用指针作函数参数，可以修改实参的值

**示例：**

//值传递
    void swap1(int a ,int b)
    {
        
    	int temp = a;
    	a = b; 
    	b = temp;
    }
    //地址传递
    void swap2(int * p1, int *p2)
    {
        
    	int temp = *p1;
    	*p1 = *p2;
    	*p2 = temp;
    }
    
    int main() {
        
    
    	int a = 10;
    	int b = 20;
    	swap1(a, b); // 值传递不会改变实参
    
    	swap2(&a, &b); //地址传递会改变实参
    
    	cout << "a = " << a << endl;
    
    	cout << "b = " << b << endl;
    
    	system("pause");
    
    	return 0;
    }

> 总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

### 2.8 指针、数组、函数 ###

**案例描述：** 封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr\[10\] = \{ 4,3,6,9,1,2,10,8,7,5 \};

**示例：**

//冒泡排序函数
    void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]
    {
        
    	for (int i = 0; i < len - 1; i++)
    	{
        
    		for (int j = 0; j < len - 1 - i; j++)
    		{
        
    			if (arr[j] > arr[j + 1])
    			{
        
    				int temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    }
    
    //打印数组函数
    void printArray(int arr[], int len)
    {
        
    	for (int i = 0; i < len; i++)
    	{
        
    		cout << arr[i] << endl;
    	}
    }
    
    int main() {
        
    
    	int arr[10] = {
         4,3,6,9,1,2,10,8,7,5 };
    	int len = sizeof(arr) / sizeof(int);
    
    	bubbleSort(arr, len);
    
    	printArray(arr, len);
    
    	system("pause");
    
    	return 0;
    }

> 总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

[ec90dcd4c1fb4c90b62073f21b690aec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/03782d141c32471795fb1c15469bdcf0.png
[7cb430446470432ba167f05bf119a35c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c7d152a7098e4be99aa5b5d154ba3e92.png
[d991430fa29d411a87c6ad72a69d5f0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4184744da9714fcea9a5c0a7b8f7e5a8.png
[c7af8257e3f04b28b37f4f369184fae4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5a54e0990650461cb02afbc20d2c91ca.png