C语言指针详解——必备7大知识点

Part1指针是什么?

1.1 浅谈指针

理解指针的 两个要点：

1. 指针是内存中一个最小单元的编号，也就是地址；

2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

总结：指针就是地址，口语中说的指针通常指的是指针变量。

1.2 内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的。所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。（每个内存单元都有地址）就好比电脑是我们的学校，内存就是学校的一个宿舍楼，而一个内存单元就代表宿舍楼中的一个宿舍，而宿舍的门牌号就表示一个地址。

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；那么32根地址线产生的地址就会是：232也就是说32位机器能够产生2的32次方个地址。每个地址标识一个字节，那我们就可以给（2^32^Byte == 2^32^/1024KB == 2^32^/1024/1024MB==2^32^/1024/1024/1024GB==4GB）4G的空间进行编址。

同理，换作64位机器，如果给64根地址线，那么将有能力管理2^32^×4GB的内存空间。

1.3 指针变量

为了能够更好的访问内存空间，我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

📝例如：

#include <stdio.h>
int main()
{
 int num = 10;//在内存中开辟一块空间
 int *p = #//这里我们对变量a，取出它的地址，可以使用&操作符。
    //num变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量
	  中，p就是一个之指针变量。
 return0; }

总结：

1. 指针变量是用来存放地址的，地址是唯一标示一个内存单元的；

2. 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以 一个指针变量的大小就应该是4个字节；

3. 在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

Part2指针和指针类型

2.1 指针类型

我们都知道，变量有不同的类型，整形，浮点型等。

那指针有没有类型呢？准确的说：有的。

C语言为我们提供了丰富的指针类型，如下：

char  *pc = NULL;//字符指针 
int   *pi = NULL;//整形指针 
short *ps =NULL;//短整型指针 
long  *pl = NULL;//长整型指针 
float *pf = NULL;//单精度浮点型指针
double *pd = NULL;//双精度浮点型指针 
……

其实：char* 类型的指针是为了存放 char 类型变量的地址。short* 类型的指针是为了存放 short 类型变量的地址。int* 类型的指针是为了存放 int 类型变量的地址。

那指针类型的意义是什么？（不知道大家有没有想过呢？）

2.2 指针±整数

📝演示实例:

//演示实例
#include <stdio.h>
int main()
{
 	int n = 10;
 	char *pc = (char*)&n;
 	int *pi = &n;
 
 	printf("%p\n", &n);
 	printf("%p\n", pc);
 	printf("%p\n", pc+1);
 	printf("%p\n", pi);
 	printf("%p\n", pi+1);
 	return0; 
 }

结果展示：

结论：指针类型决定了指针的步长（向前 / 向后 走一步多大距离）

1. char* 指针 + 1，意思是跳过一个字符，也就是向后走1个字节；

2. short* 指针 + 1，向后走2个字节；

3. int* 指针 + 1，意思是跳过1个整形，也就是向后走4个字节；

4. double* 指针 + 1，意思是跳过一个double，也就是向后走8个字节；

5. ……

2.3 指针的解引用

📝演示实例：

//演示实例
#include <stdio.h>
int main()
{
 	int n = 0x11223344;
 	char *pc = (char *)&n;
 	int *pi = &n;
 	*pc = 0;   //重点在调试的过程中观察内存的变化。
 	*pi = 0;   //重点在调试的过程中观察内存的变化。
 	return0; 
 }

调试结果：

结论：指针类型决定了，指针解引用操作的时候，访问几个字节（权限）。

1. char* 的指针解引用访问1个字节；

2. int * 的指针解引用访问4个字节；

3. double* 的指针，解引用访问8个字节；

4. ……

Part3野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。

3.1 野指针成因

3.1.1 指针未初始化

#include <stdio.h>
int main()
{ 
 	int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
 	return0; 
}

注释：局部变量指针未初始化，默认为随机值。

3.1.2 指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
   }
    return0;
}

注释：当指针指向的范围超出数组arr的范围时，p就是野指针。

3.1.3 指针指向的空间释放

int* test()
{
	int num = 100;
	return #//出了函数，这块内存就不属于我们了，还给了操作系统
}
 
int main()
{
	int* p = test();
	*p = 200;
	return0;
}

注释：变量num为局部变量，生命周期从创建开始到出test函数结束，test函数调用结束后num会将空间还给操作系统，此时回到主函数p的地址已经被释放，此时p就是野指针。

3.2 如何规避野指针

1. 指针初始化（已知指向时明确初始化；未知初始化为NULL）；

2. 小心指针越界；

3. 指针指向空间释放，及时置NULL；

4. 避免返回局部变量的地址；

5. 指针使用之前检查有效性。

检查指针有效性，原理：空指针NULL位于内核区域不能直接访问。

#include <stdio.h>
int main()
{
    int *p = NULL;//未知指向初始化为NULL
    int a = 10;
    p = &a;//明确初始化
    if(p != NULL)//为空指针不访问（无效指针）
   {
        *p = 20;//不为空再访问
   }
    return0; 
}

Part4指针运算

4.1 指针± 整数

📝例如：通过指针加减整数遍历数组元素

int main()
{
	double arr[5] = {0};
	double* p = arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%lf ", *(p + i));
	}
 
	return0;
}

4.2 指针的关系运算

📝例如：通过指针初始化数组；

#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float* vp;
	for (vp = &values[N_VALUES]; vp > &values[0];)
	{
		*--vp = 0;
	}
}

代码简化，故将代码修改如下：

#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float* vp;
	for (vp = &values[N_VALUES - 1]; vp >= &values[0]; vp--)
	{
		*vp = 0;
	}
}

实际在绝大部分的编译器上以上两种写法都是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与 指向第一个元素之前的那个内存位置的指针进行比较。

4.3 指针-指针

注释：指针和指针相减的绝对值等于指针和指针之间元素的个数。|p2-p1|==p1p2间元素个数

#include<stdio.h>
int main()
{
	
	int arr[10] = {0};
	printf("%d\n", &arr[9] - &arr[0]);
	printf("%d\n", &arr[0] - &arr[9]);
	
	//两个指针相减的前提是：指针指向的同一块连续的空间
	//int a = 10;
	//char c = 'w';
	//printf("%d\n", &a - &c);//err
 
	return0;
}

补充：指针+指针没有意义。

Part5指针和数组

5.1 区别

1. 数组和指针不是一个东西；

2. 数组能够存放一组数，连续的空间，数组的大小取决于元素个数；

3. 指针是一个变量，是存放地址的。

5.2 联系

数组名是地址（指针） 数组名把首元素的地址，交给一个指针变量后，可以通过指针来访问数组。

📝通过指针和数组的联系，我们可以利用指针的偏移和解引用访问数组中的元素：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
 
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return0;
}
//输出：1 2 3 4 5 6 7 8 9 10

Part6二级指针

6.1 二级指针详解

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

答案是：二级指针。

int main()
{
	int a = 10;//
	int *pa = &a;//pa就是指针变量，一级指针变量，表示指针指向的a是int
	int* *ppa = &pa;//ppa就二级指针，表示pp指向的p的类型是int*
	return0;
}

二级指针的运算：

1. *ppa通过对ppa中的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa；
   int b = 20;
``` ``*ppa = &b;
//等价于 pa = &b;

2. **ppa先通过*ppa找到pa ,然后对pa进行解引用操作：*pa，那找到的是a；
   **ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

6.2 多级指针

我们将问题故意复杂化一点，你想成为五星程序员吗？

#include <stdio.h>
int main()
{
    int n = 123;                        // int 
    int *oneStar = &n;                  // int *
    int **twoStar = &oneStar;           // int **
    int ***threeStar = &twoStar;        // int ***
    int ****fourStar = &threeStar;      // int ****
    int *****fiveStar = &fourStar;      // int *****
 
    printf("n = %d\n", *****fiveStar);  // 五次取值，还原为int
    return0;
}

Part7指针数组

7.1 初识指针数组

指针数组是指针还是数组？

答案：是数组，是存放指针的数组。

int main()
{
	//整型数组-存放整型的数组
	int arr[10];
	//字符数组-存放字符的数组
	char arr2[5];
	//指针数组-存放指针的数组
	int* arr3[5];//存放整型指针的数组
	char* arr4[6];//存放字符指针的数组
 
	return0;
}

📝例如：

7.2 指针数组的使用

📝用一维数组模拟一个二维数组：

int main()
{
	//用一维数组模拟一个二维数组
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int arr4[] = { 4,5,6,7,8 };
 
	int* arr[4] = {arr1, arr2, arr3, arr4};//用指针数组管理一维数组
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
 
	return0;
}