C++阶段01笔记07【指针（基本概念、变量定义和使用、内存空间、空指针和野指针、const修饰指针、指针和数组、指针和函数）】

爱被打了一巴掌 2022-11-13 00:59 129阅读 0赞

> [C++| 匠心之作 从0到1入门学编程【视频+课件+笔记+源码】][C_ _ _0_1]

**目录**

7 指针

7.1 指针的基本概念

7.2 指针变量的定义和使用

示例

7.3 指针所占内存空间

示例

7.4 空指针和野指针

示例1：空指针

示例2：野指针

总结

7.5 const修饰指针

1、const修饰指针——常量指针

2、const修饰常量——指针常量

3、const既修饰指针，又修饰常量

示例

7.6 指针和数组

示例

7.7 指针和函数

示例

7.8 指针、数组、函数

示例

--------------------

# 7 指针 #

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

> **指针的作用：** 可以通过指针间接访问内存。
> 
>  *  内存编号是从0开始记录的，一般用十六进制数字表示。
>  *  可以利用指针变量保存地址。

> *内存都是有地址编号的，从0开始记录，一般用十六进制数字来表示编号，可以利用指针来记录地址编号。*
> 
> *int a = 10; // 4字节空间大小* 
> 
> *每创建一个变量，都要去记录地址编号，不太方便去使用这个数据，所以才会有这个变量。*
> 
> *知道地址编号，也可以拿到数据。**指针就是一个地址，记录地址编号！***
> 
> ![20210324212604569.png][]

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

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

### 示例 ###

> 指针变量和普通变量的区别：
> 
>  *  普通变量存放的是数据，指针变量存放的是地址。
>  *  指针变量可以通过 “ \* ” 操作符，操作指针变量指向的内存空间，这个过程称为解引用。

> ![20210324213612988.png][] 通过p可以找到内存，通过\*p可以修改内存。
> 
> 指针的作用（用途）：可以间接地访问内存，并且对其进行读和写的操作（修改、访问）！
> 
> ![20210324214530357.png][]  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70][]

#include <iostream>
    using namespace std;
    
    int main()
    {
    	//1、指针的定义
    	int a = 10; //定义整型变量a
    
    	//指针定义的语法：数据类型 * 指针变量名 ;
    	int *p; // point代表指针
    
    	//指针变量赋值 让指针记录变量a的地址
    	p = &a;	//指针p指向（等于）变量a的地址【取地址符号& 取变量a的地址】建立变量与指针之间的关系
    	cout << "a的地址为：" << &a << endl; //打印数据a的地址：0x61fe14
    	// cout << "a的地址为：" << (int)&a << endl; //十六进制转整型
    	cout << "指针p为：" << p << endl; //打印指针变量p：0x61fe14【指针就是一个地址，记录地址编号！】
    
    	//2、指针的使用
    	//可以通过“解引用”的方式来找到指针指向的内存
    	//指针前加一个* 代表 解引用，找到指针指向的内存中的数据
    	//通过*操作指针变量指向的内存
    	cout << "*p = " << *p << endl; // 10
    
    	*p = 1000; //解引用 通过指针间接地找到了a的内存 通过解引用拿到p指向的内存中的数据（进行 修改、读取）
    	cout << "a = " << a << endl;
    	cout << "*p = " << *p << endl;
    
    	system("pause");
    	return 0;
    }

> 总结1： 我们可以通过 & 符号 获取变量的地址。
> 
> 总结2：利用指针可以记录地址。
> 
> 总结3：对指针变量解引用，可以操作指针指向的内存。

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

> 提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？
> 
> 总结：所有指针类型在32位操作系统下是4个字节，在64位操作系统下是8字节。

### 示例 ###

> ![20210325124318691.png][]
> 
> ![20210325125004765.png][] ![2021032512521751.png][]

#include <iostream>
    using namespace std;
    
    int main() //指针所占内存空间
    {
    	int a = 10;
    
    	// int *p;
    	// p = &a; //指针指向数据a的数据地址
    	int *p = &a; //建立关系
    
    	//在32位操作系统下，指针是占4个字节空间大小（不管是什么数据类型）
    	//在64位操作系统下，指针是占4个字节空间大小（不管是什么数据类型）
    	cout << *p << endl;										   //10 * 解引用
    	cout << "sizeof(p) = " << sizeof(p) << endl;			   //8 查看变量（数据类型）占用的内存空间
    	cout << "sizeof(int *) = " << sizeof(int *) << endl;	   //8
    	cout << "sizeof(float *) = " << sizeof(float *) << endl;   //8
    	cout << "sizeof(double *) = " << sizeof(double *) << endl; //8
    	cout << "sizeof(char *) = " << sizeof(char *) << endl;	   //8
    	system("pause");
    	return 0;
    }

## 7.4 空指针和野指针 ##

> **空指针**：指针变量指向内存中编号为0的空间。*内存条，都有自己的编号，从0开始递增。指向编号为0的指针，称为“空指针”！*
> 
> **用途：**初始化指针变量。*指针一开始不知道指向哪里好，就指向内存中编号为0的空间。*
> 
> **注意：**空指针指向的内存是不可以访问的。*无权利访问空指针指向的内存。0~255之间的这块内存，是系统占用的，一旦访问，就会出错！*

### 示例1：空指针 ###

> ![20210325130624288.png][]

> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 1][]
> 
> ![20210325130913842.png][]
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 2][]

> ![20210325131346422.png][]

#include <iostream>
    using namespace std;
    
    int main() //空指针
    {
    	//1、空指针用于给指针变量进行初始化
    	// int * p;//指针指向哪？未知！所以，一般会让指针指向NULL（空）
    	int *p = NULL; //指针变量p指向内存地址编号为0的空间
    
    	//2、空指针是不可以进行访问的
    	//0~255之间的内存编号是系统占用的，因此不可以访问
    	*p = 100; //直接引用 操作内存
    	//访问空指针报错
    	//内存编号0 ~255为系统占用内存，不允许用户访问
    	cout << *p << endl;
    
    	//system("pause");
    	return 0;
    }

### 示例2：野指针 ###

> **野指针**：指针变量指向非法的内存空间。*非法的内存空间：不是使用者申请的内存空间。*

> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 3][]
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 4][]

> ![20210325132518779.png][]

#include <iostream>
    using namespace std;
    
    int main() //野指针 在程序中，尽量避免出现野指针
    {
    	// int *p = NULL;
    	//指针变量p指向内存地址编号为0x1100的空间【0x1100：十六进制数字】
    	int *p = (int *)0x1100; //变为地址：(int *)强转为指针类型
    	//0x1100随便在内存中指向了这样一个编号，这个编号中的数 无权利操作！没有申请，无权利操作！
    	//举例：花钱买房间A（int a = 10; int *p = &a;），没有权利去房间B（房间B->野指针）
    
    	cout << *p << endl; //访问野指针报错
    
    	system("pause");
    	return 0;
    }

### 总结 ###

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

## 7.5 const修饰指针 ##

> const修饰指针有3种情况：
> 
> 1.  const 修饰指针 —— 常量指针        const int \*p1 = &a;
> 2.  const 修饰常量 —— 指针常量        int \*const p2 = &a;
> 3.  const 既修饰指针，又修饰常量

### 1、const修饰指针——常量指针 ###

> ![20210325140136964.png][]
> 
> 红框：被限定，不可以修改；黑线：可以修改。

### 2、const修饰常量——指针常量 ###

> ![20210325140100379.png][]
> 
> 红线：被限定，不可以修改；黑框：可以修改。

### 3、const既修饰指针，又修饰常量 ###

> ![20210325135924585.png][]

### 示例 ###

> ![20210325140753316.png][] ![20210325141242611.png][]

#include <iostream>
    using namespace std;
    
    int main()
    {
    	int a = 10;
    	int b = 10;
    	//int *p0 = &a; //普通写法
    
    	//1、常量指针(记法：const在前 先常量 后指针)
    	//const修饰的是指针，指针的指向可以更改，指针指向的值不可以更改(可以理解为const 修饰的是解引用 int*，所以指针指向的值不可以更改)
    	const int *p1 = &a;
    	p1 = &b; //正确
    	// *p1 = 20; //错误
    
    	//2、指针常量(记法：int* 在前 先指针 后常量)
    	//const修饰的是常量，指针的指向不可以更改，指针指向的值可以更改(可以理解为const修饰的是指针本身，所以指针指向的值不可以修改)
    	int *const p2 = &a;
    	*p2 = 100; //正确
    	//p2 = &b; //错误，指针常量 指针的指向不可以更改
    
    	//3、const既修饰指针又修饰常量
    	const int *const p3 = &a;
    	//指针的指向和指针指向的值都不可以改
    	//*p3 = 100; //错误
    	//p3 = &b; //错误
    
    	system("pause");
    	return 0;
    }

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

## 7.6 指针和数组 ##

> **作用：**利用指针访问数组中元素。*数组：一段连续的空间中，存放了相同类型的数据元素。*

### 示例 ###

> ![20210325143023643.png][]
> 
> ![20210325143345907.png][]  ![20210325143405701.png][]

#include <iostream>
    using namespace std;
    
    int main()
    {
    	//指针和数组
    	//让（利用）指针也能访问数组中的每一个元素
    	int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    	cout << "第一个元素为：" << arr[0] << endl;
    
    	int *p = arr; //指向数组的指针 数组是整型的，所以创建整型指针，指向数组的地址 arr数组名就是数组的首地址
    	//指针指向数组首地址，对指针进行解引用的操作，就可以解出数组中的第一个元素
    	cout << "利用指针访问第一个元素：" << *p << endl; //*p解引用
    
    	p++; //指向数组中的第二个元素，让指针向后偏移（移动）4个字节（整型指针）
    	cout << "利用指针访问第二个元素：" << *p << endl; //*p解引用
    
    	cout << "利用指针遍历数组：" << endl;
    	int *p2 = arr;
    	for (int i = 0; i < 10; i++) //利用指针遍历数组
    	{
    		// cout << arr[i] << endl;
    		cout << *p2 << endl;
    		p2++;
    	}
    
    	system("pause");
    	return 0;
    }

## 7.7 指针和函数 ##

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

### 示例 ###

> ![20210325144828247.png][] ![20210325144333704.png][]
> 
> 指针保存的是地址。传递地址，可以间接地改变实参数据。

#include <iostream>
    using namespace std;
    
    //1、值传递：实现两个数字进行交换
    void swap01(int a, int b)
    {
    	int temp = a;
    	a = b;
    	b = temp;
    	cout << "swap01中 a = " << a << endl;
    	cout << "swap01中 b = " << b << endl;
    }
    
    //2、地址传递
    void swap02(int *p1, int *p2)
    {
    	int temp = *p1; //解出内存 解引用
    	*p1 = *p2;
    	*p2 = temp;
    	cout << "swap02中 *p1 = " << *p1 << endl;
    	cout << "swap02中 *p2 = " << *p2 << endl;
    }
    
    int main() //指针和函数
    {
    	int a = 10;
    	int b = 20;
    
    	//1、值传递不会改变实参
    	swap01(a, b);
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    
    	//2、地址传递会改变实参
    	//将a、b变量地址传入函数体中，用指针接受地址【如果是地址传递，可以修饰实参】
    	swap02(&a, &b);
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    
    	system("pause");
    	return 0;
    }

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

## 7.8 指针、数组、函数 ##

> **案例描述：**封装一个函数，利用冒泡排序，实现对整型数组的升序排序。
> 
> 例如数组：int arr\[10\] = \{ 4,3,6,9,1,2,10,8,7,5 \};

### 示例 ###

> ![20210325150003147.png][]

#include <iostream>
    using namespace std;
    
    //冒泡排序函数【参数1：数组首地址；参数2：数组长度】
    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]) //如果j > j + 1的值，交换数字
    			{
    				int temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    }
    
    //打印数组函数
    void printArray(int arr[], int len) //void printArray(int *arr, int len)
    {
    	for (int i = 0; i < len; i++)
    	{
    		// cout << arr[i] << endl;
    		cout << arr[i] << "、";
    	}
    }
    
    int main()
    {
    	//1、创建一个数组
    	int arr[10] = {4, 3, 6, 9, 1, 2, 10, 8, 7, 5};
    	//数组长度
    	int len = sizeof(arr) / sizeof(int);
    
    	//2、创建一个函数实现冒泡排序
    	bubbleSort(arr, len); //传递数组地址arr：数组名就是数组的首地址
    
    	//3、打印排序后的数组
    	printArray(arr, len); //传递数组地址arr
    
    	system("pause");
    
    	return 0;
    }

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

[C_ _ _0_1]: https://blog.csdn.net/weixin_44949135/article/details/115025771
[20210324212604569.png]: /images/20221022/2d22a1863a2e40778c5c6c13451b7b00.png
[20210324213612988.png]: /images/20221022/9884cdcf864f42e1a2f4f8b22126708b.png
[20210324214530357.png]: https://img-blog.csdnimg.cn/20210324214530357.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70]: /images/20221022/be00d0bf26314578ba952fd79c05afdc.png
[20210325124318691.png]: /images/20221022/acf49453c7a844d38668af1fe4d063bd.png
[20210325125004765.png]: https://img-blog.csdnimg.cn/20210325125004765.png
[2021032512521751.png]: /images/20221022/a8ffc9e503f14af7b6c50192b0daad4a.png
[20210325130624288.png]: /images/20221022/430aa8360a20479a92eda6476f696592.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 1]: /images/20221022/c987613b2e824424b0d82c178ddef704.png
[20210325130913842.png]: /images/20221022/114a78db12c74254a1d1d01f0e828bd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 2]: /images/20221022/586ff7aaeff7437883920efe7f89abd9.png
[20210325131346422.png]: /images/20221022/b722a52ec80c4eb7879f853211be4bd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 3]: /images/20221022/d2ba222c1beb4c6e8ce8ca296182aaae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 4]: /images/20221022/a535e7e5bf3b4280a6fb03a3faed7896.png
[20210325132518779.png]: /images/20221022/9bd87b9407a543e4b6a1f4d05f70162c.png
[20210325140136964.png]: /images/20221022/4c4897bcf5fe47f380469ca58cede881.png
[20210325140100379.png]: /images/20221022/4235591922ba4634a46115bda19edb26.png
[20210325135924585.png]: /images/20221022/2e0ceee91e0849768cf663fbedcbf190.png
[20210325140753316.png]: https://img-blog.csdnimg.cn/20210325140753316.png
[20210325141242611.png]: /images/20221022/6c0810c425154c93afe1b2c05d8d25bc.png
[20210325143023643.png]: /images/20221022/92e8c3ccfb4f4f7f85b11c36f34c57ef.png
[20210325143345907.png]: https://img-blog.csdnimg.cn/20210325143345907.png
[20210325143405701.png]: /images/20221022/a8faede8c76443838a1d25f4062272e4.png
[20210325144828247.png]: https://img-blog.csdnimg.cn/20210325144828247.png
[20210325144333704.png]: /images/20221022/1533405b15944e09b0ce9880730ec01e.png
[20210325150003147.png]: /images/20221022/5aebd59fb11e42888eb06d95aecac1d6.png