C++学习笔记——指针

发表于2020-11-25更新于2022-06-05字数统计1.4k阅读时长10分

1. 指针的基本概念

指针的作用：可以通过指针间接访问内存，指针就是一个地址

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

2. 指针变量的定义和使用

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

实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
using namespace std;

int main() {
	//1.定义zhizhen
	int a = 10;
	// 指针定义的语法：数据类型 * 指针变量名
	int * p;
	// 让指针记录变量a的地址
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//2.使用指针
	//可以通过解引用的方式来找到指针指向的内存
	// 指针前加 * 代表解应用，找到指针指向内存中的数据，然后进行读和写的操作
	*p = 1000;
	cout << "a = " << a << endl;
	cout << "*p = " << *p << endl;


	system("pause");
	return 0;
}

示意图：
在这里插入图片描述

3. 指针所占用内存空间

  • 在32位操作系统下，指针是占4个字节空间大小，不管是什么类型
  • 在64位操作系统下，指针是占8个字节空间大小

在这里插入图片描述
实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream>
using namespace std;

int main() {

	//指针所占用内存空间
	int a = 10;
	int * p = &a;

	// 在32位操作系统下，指针是占4个字节空间大小，不管是什么类型
	// 在64位操作系统下，指针是占8个字节空间大小
	// sizeof(p)和sizeof(int *)一样
	cout << "sizeof （int *) = " << sizeof(int *) << endl;
	cout << "sizeof （float *) = " << sizeof(float *) << endl;
	cout << "sizeof （double *) = " << sizeof(double *) << endl;
	cout << "sizeof （char *) = " << sizeof(char *) << endl;
	system("pause");
	return 0;
}

4. 空指针和野指针

  • 空指针：指针变量指向内存中编号为0的空间
  • 用途：初始化指针变量
  • 注意：空指针指向的内存是不可以访问的

示例1：空指针

1
2
3
4
5
6
7
8
9
10
11
12
13
int main() {

	//空指针
	// 1、空指针用于给指针变量进行初始化
	int * p = NULL;
	// 2、空指针是不可以进行访问的
	// 0~255之间的内存编号是系统占用的，因此不可以访问
	*p = 100;
	// 会报错

	system("pause");
	return 0;
}
  • 野指针：指针变量指向非法的内存空间

示例2：野指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main() {

	//野指针
	// 在程序中，尽量避免出现野指针

	// 指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;
	
	// 访问野指针报错
	cout << *p << endl;
	// 引发了异常: 读取访问权限冲突。因为你没有申请这个地址所指向的内存空间，却又访问它
	system("pause");
	return 0;
}

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

5. const修饰指针

const修饰指针三种情况：

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

示例1：常量指针（红线标注的是错误的方式）
在这里插入图片描述

示例2：指针常量（红线标注的是错误的方式）

在这里插入图片描述
示例3：const即修饰指针，又修饰常量（红线标注的是错误的方式）
在这里插入图片描述

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int main() {
	// 1、const修饰指针
	int a = 10;
	int b = 10;

	const int * p = &a;
	// 指针指向的值不可以改，指针的指向可以改
	// *p = 20; 错误
	p = &b; //正确

	// 2、const修饰常量 指针常量
	int * const p2 = &a;
	*p2 = 100; //正确
	// p2 = &b; //错误，指针的指向不可以改
	// 3、const修饰指针和常量
	const int * const p3 = &a;
	// 指针的指向和指针指向的值 都不可以改
	// *p3 = 100; //错误
	// p3 = &b; //错误
}

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

6. 指针和数组

  • 作用：利用指针访问数据数据中元素

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main() {
	//指针和数组
	//利用指针访问数组中的元素

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "第一个元素为：" << arr[0] << endl;
	int * p = arr;//arr就是数组首地址
	cout << "利用指针访问第一个元素：" << *p << endl;
	//p++不是把地址加1，是指针偏移一个单位，在32位下是偏移4个字节，在64位下，偏移8个字节
	p++;
	cout << "利用指针访问第二个元素：" << *p << endl;
	system("pause");
	return 0;
}

7. 指针和函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include<iostream>
using namespace std;


void swap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}

void swap02(int *p1, int *p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	// 指针和函数
	//1、值传递 不会改变实参的值
	int a = 10;
	int b = 20;
	swap01(a, b);
	cout << "值传递：\n";
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;


	//2、地址传递 会改变实参的值
	cout << "地址传递：\n";
	swap02(&a, &b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

示例图如下
在这里插入图片描述

8. 指针、数组、函数组合案例

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

例如数组：int arr[10] = {4,3,6,8,1,2,10,8,7,5}
在这里插入图片描述