C++基础入门（七）—— 指针

C++系列内容的学习目录$\to$C++学习系列内容汇总。

1. 指针的基本概念

  指针是一个变量，其值为另一个变量的地址，即内存位置的直接地址。

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

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

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

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

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

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

  实例如下所示。

#include
using namespace std;

int main()
{

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

	//2.使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加 * 代表解引用，找到指针指向的内存中的数据
	cout << "a = " << a << endl;
	cout << "p = " << *p << endl;

	system("pause");

	return 0;
}

a的地址为：012FF76C
指针p为：012FF76C
a = 10
p = 10

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

3. 指针所占内存空间

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

  实例如下所示。

#include
using namespace std;

int main()
{

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

	//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
	//在64位操作系统下，指针是占8个字节空间大小
	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;
}

sizeof(int *) = 4
sizeof(float *) = 4
sizeof(double *) = 4
sizeof(char *) = 4

  总结： 所有指针类型在32位操作系统下是占4个字节，在64位操作系统下是占8个字节。

4. 空指针和野指针

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

  空指针的用途： 初始化指针变量。

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

  空指针的实例如下所示。

#include
using namespace std;

int main()
{

	//空指针
	//1.空指针用于给指针变量进行初始化
	int * p = NULL;

	//2.空指针是不可以进行访问的
	//0 ~ 255之间的内存编号是系统占用的，因此不可以访问
	//* p = 100;  //引发了异常: 写入访问权限冲突。
	//cout << *p << endl;  //引发了异常: 读取访问权限冲突。

	system("pause");

	return 0;
}

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

  野指针的实例如下所示。

#include
using namespace std;

int main()
{

	//野指针
	//在程序中，尽量避免出现野指针
	int * p = (int *)0x1100;  //地址0x1100不是我们申请的，不能对其操作

	//cout << *p << endl;  //引发了异常: 读取访问权限冲突。

	system("pause");

	return 0;
}

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

5. const修饰指针

  const修饰指针有三种情况：

1. const修饰指针 —— 常量指针
   特点：指针的指向可以修改，但指针指向的值不可以修改。
2. const修饰常量 —— 指针常量
   特点：指针的指向不可以修改，但指针指向的值可以修改。
3. const既修饰指针，又修饰常量
   特点：指针的指向和指针指向的值都不可以更改。

  实例如下所示。

#include
using namespace std;

int main()
{

	//const修饰指针
	//1.const修饰指针——常量指针
	int a = 10;
	int b = 10;

	const int * p1 = &a;
	//指针指向的值不可以修改，指针的指向可以修改
	//* p1 = 100;  //错误
	p1 = &b;

	//2.const修饰常量
	//指针的指向不可以修改，指针指向的值可以修改
	int * const p2 = &a;
	*p2 = 100;
	//p2 = &b;  //错误

	//3.const既修饰指针，又修饰常量
	const int * const p3 = &a;
	//指针的指向不可以修改，指针指向的值也不可以修改
	//*p3 = 100;  //错误
	//p3 = &b;  //错误

	system("pause");

	return 0;
}

6. 指针和数组

  指针和数组是密切相关的。事实上，指针和数组在很多情况下是可以互换的。例如，一个指向数组开头的指针，可以通过使用指针的算术运算或数组索引来访问数组。

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

  实例如下所示。

#include
using namespace std;

int main()
{

	//指针和数组
	//利用指针访问数组中的元素

	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	cout << "第一个元素为：" << arr[0] << endl;

	int * p1 = arr;  //arr就是数组的首地址
	cout << "利用指针访问第一个元素：" << *p1 << endl;
	p1++;  //让指针向后偏移4个字节
	cout << "利用指针访问第二个元素：" << *p1 << endl;

	cout << "利用指针遍历数组" << endl;
	int * p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p2 << endl;
		p2++;
	}

	system("pause");

	return 0;
}

第一个元素为：1
利用指针访问第一个元素：1
利用指针访问第二个元素：2
利用指针遍历数组
1
2
3
4
5
6
7
8
9
10

7. 指针和函数

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

  实例如下所示。

#include
using namespace std;

//实现两个数字之间进行交换的函数
void swap1(int num1, int num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "swap1 num1 = " << num1 << endl;
	cout << "swap1 num2 = " << num2 << endl;
}

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

	cout << "swap2 *p1 = " << *p1 << endl;
	cout << "swap2 *p2 = " << *p2 << endl;
}

int main()
{
	//指针和函数
	//1.值传递
	int a = 10;
	int b = 20;
	swap1(a, b);

	cout << "a = " << a << endl;  //实参未发生改变
	cout << "b = " << b << endl;

	//2.地址传递
	//如果是地址传递，可以修饰实参
	swap2(&a, &b);

	cout << "a = " << a << endl;  //实参发生改变
	cout << "b = " << b << endl;

	system("pause");

	return 0;
}

swap1 num1 = 20
swap1 num2 = 10
a = 10
b = 20
swap2 *p1 = 20
swap2 *p2 = 10
a = 20
b = 10

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

• 值传递

• 地址传递

8. 指针、数组、函数

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

  练习案例的代码如下所示。

#include
using namespace std;

//冒泡排序函数：参数1 数组的首地址；参数2 数组长度
void bubbleSort(int *arr, int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i -1; 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)
{
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
}
int main()
{
	//1.创建数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	//2.创建函数，实现冒泡排序
	bubbleSort(arr, len);

	//3.打印排序后的数组
	printArray(arr, len);

	system("pause");

	return 0;
}

1
2
3
4
5
6
7
8
9
10

  总结： 将一个数组传入到一个函数中， 需要把数组首地址传入，利用指针int *arr接收首地址。

9. 总结