第七章 指针

7 指针

7.1 指针的定义与使用

int a = 1000;
int* p = &a;
cout << "a  = " << a << endl;
cout << "&a = " << &a << endl;
cout << "p  = " << p << endl;
cout << "*p = " << *p << endl;
cout << "&p = " << &p << endl;
cout << "sizeof(int*) = " << sizeof(int*) << endl;

/***************输出结果***************/
// a  = 1000
// &a = 00000071256FF7B4
// p  = 00000071256FF7B4
// *p = 1000
// &p = 00000071256FF7D8
// sizeof(int*) = 8

变量名	地址	值
a	00000071256FF7B4	1000
p	00000071256FF7D8	00000071256FF7B4

• 指针的值是地址 ：p = &a

• 指针解引用后是其指向地址中存储的值 ：*p = a

• 指针本身作为一个变量，其也有自己的地址，但是目前对用户没啥用

• 易错：指针变量是p而非*p，在定义时p的数据类型为 int*

• 指针变量的数据类型取决于其指向地址中存储的数据的类型

• 在64位系统中，所有数据类型的指针都占 8 Byte，因为存的是地址，地址长度是固定的，32位是4Byte

7.2 空指针与野指针

1. 野指针：定义指针但未指向具体的地址，或是指向了一段非法的、不可访问的内存空间的指针

2. 空指针：为了避免野指针带来的危险，所以在不确定指针指向何处时，现将指针初始化为空指针，即int* p = NULL

   注意：空指针是0000000000000000，是一个不可访问的内存空间

7.3 const修饰指针

1. const修饰指针 const int* p = &a

   此时p为常量指针：指针指向的地址可改，指针指向地址中的值不可改

2. const修饰常量 int* const p = &a

   此时p为指针常量：指针指向的地址不可改，指针指向地址中的值可以改

3. const修饰指针和常量 const int* const p = &a

   指针指向的地址不可改，指针指向地址中的值不可改

   int a = 10, b = 20;
   const int* p1 = &a;	// 常量指针
   int* const p2 = &a;	// 指针常量
   const int* const p3 = &a;
   
   p1 = &b;	// 可修改指针指向地址
   *p2 = 20;	// 可修改指针指向地址中的值
   

   巧记：在定义时，先常量（const）再指针（*）即为常量指针；先指针（*）再常量（const）即为指针常量

7.4 指针和数组

将指针初始化为数组的首元素首地址后，使用++p可实现指针对数组元素的遍历

int a[2] = { 0,1 };
double b[2] = { 1.11,2.22 };
int* p = a;
double* p_b = b;
cout << "&a[0] = " << p << "\t";
cout << "a[0]  = " << *p << endl;
cout << "&a[1] = " << ++p << "\t";
cout << "a[1]  = " << *p << endl;

cout << "&b[0] = " << p_b << endl;
cout << "&b[1] = " << ++p_b << endl;

/************* 输出结果 ************/
// &a[0] = 00000098ED58FB98        a[0]  = 0
// &a[1] = 00000098ED58FB9C        a[1]  = 1
// &a[2] = 00000098ED58FBA0        a[2]  = 2
// &b[0] = 0000008825CFF838
// &b[1] = 0000008825CFF840

由实例可以看出：指向数组的指针p在++p后并不是地址加一，而是＋sizeof（数组数据类型），故可以实现数组各元素地址的跳转

7.5 指针和函数

这里书接6.2中的指针传递

/**************** 指针传递 ****************/
void my_swap(int* a, int* b) 
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

/**************** 主函数 *****************/
int main(){
	int a = 1,b = 2;
	my_swap(&a, &b);
}

1. 与值传递区别：

   • 传入的参数是一个指针（地址）

   • 函数体内部对指针解引用后进行交换，实现对实际地址的操作，对现实产生了影响

2. 与引用传递区别：

   • 引用传递相当于对传入的实参进行了虚拟现实，通过设置变量的“别名”直接对实参进行了修改，是在“变量名”层面的操作
   • 指针传递相当于传入的是地址，直接在实际的地址上进行修改，是在“地址”层面的操作

指针+数组+函数实例：

/********** 封装函数，对数组进行冒泡升序排列 **********/

#include <iostream>
using namespace std;

void Bubble_sort(int* p, int n) {
	int temp;
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = i + 1; j < n; j++)
		{
			if (*(p + i) > *(p + j))
			{
				temp = *(p + j);
				*(p + j) = *(p + i);
				*(p + i) = temp;
			}
		}
	}
}

int main() {
	int arr[10] = { 1,5,7,32,41,20,51,21,60,0 };
    int len = sizeof(arr)/sizeof(arr[0]);
	Bubble_sort(arr, len);
	for (int i = 0; i < len; i++)
		cout << arr[i] << " ";

	system("pause");
	return 0;
}