让你不再惧怕指针——C语言指针及指针进阶详解
目录
一、指针初阶
1.指针是什么
2.指针和指针类型
2.1指针
2.2指针的类型
2.3指针加减整数
2.4指针的解引用
3.野指针
3.1野指针的成因
3.2 如何在写代码的过程中规避野指针
4.指针运算
5.指针和数组
6.二级指针
二、指针进阶
1.字符指针
2.指针数组
3.数组指针
3.1数组指针的定义
3.2&数组名VS数组名
4.函数指针
5.函数指针数组
6.指向函数指针数组的指针
一、指针初阶
1.指针是什么
我们要从32位或64位机器讲起，对于32位机器来说是由32根总线，这里的位也可以理解为比特位也就是4字节，机器通电后每根地址线会有正负两种电性，正点代表1，负电代表0；所以总共有2^32种可能，也就是2^32个地址，一个小单元为一个字节，一个字节给对应的的地址；
这里我们就明白：
1. 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
2. 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地
址。
我们也可以这样理解：
1. 内存和内存地址：在计算机中，内存是用于存储数据的地方。每个内存单元都有一个唯一的地址，用于标识和访问它。我们可以将内存地址视为存储数据的房间号，而内存单元则是房间中存放的数据。
2. 指针的定义和作用：指针是一种特殊的变量，它存储了一个内存地址。可以将指针视为存放房间号的盒子，它并不存放数据本身，而是指向存放数据的内存位置。指针的作用是提供了直接访问和操作内存中数据的能力。
我们可以将指针比喻为计算机中的房间号，它允许我们直接访问和操作内存中的数据。
总结：
1. 指针变量是用来存放地址的，地址是唯一标示一个内存单元的。
2. 指针的大小在32位平台是4个字节，在64位平台是8个字节。
指针是什么？
指针理解的2个要点：
1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
总结：指针就是地址，口语中说的指针通常是指指针变量
2.指针和指针类型
2.1指针
我们可以用&操作符取出一个变量的地址，存储在一个int * 类型的变量中
int main()
{
int a = 10;
//在创建a变量的同时在内存中开辟一个int大小的空间存储a变量
int* pa = &a;
//使用&操作符取出a的地址
//int* 表明pa是一个指针 存储着a变量的地址 也代表着pa指向a变量
return 0;
}2.2指针的类型
我们知道在C语言中有着不同的变量类型，例如：整形，浮点型等。那指针有没有类型呢？
准确的说：有的（这里的NULL表示将指针置空，没有指向任何空间）
int *pa=NULL;//表明指针pa是存放int类型变量的地址
char *pc=NULL;//表明指针pc是存放char类型变量的地址
short *ps=NULL;//表明指针ps是存放short类型变量的地址
long *pl=NULL;//表明指针pl是存放long类型变量的地址
float *pf=NULL;//表明指针pf是存放float类型变量的地址
double *pb=NULL;//表明指针pb是存放double类型变量的地址这就是指针的类型，定义方式：type+*，*表明定义一个指针，type是这个指针的类型
2.3指针加减整数
int main()
{
int n = 10;
char* pc = (char*)&n;
int* pa = &n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc + 1);
printf("%p\n", pa);
printf("%p\n", pa + 1);
return 0;
}
总结：这就是指针类型的意义决定指针向前或者向后走一步有多大（距离）
2.4指针的解引用
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;
int* pa = &n;
*pc = 0;
*pa = 0;
return 0;
}
总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如：按照上面的例子char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
3.野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1野指针的成因
1. 指针未初始化
#include
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
} 2. 指针越界访问
int main()
{
int arr[10] = {0};
int *p = arr;
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}3.2 如何在写代码的过程中规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
4.指针运算
指针-指针
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* left = arr;
while (*left != 10)
{
left++;
}
printf("%d\n",left-arr);
return 0;
}
总结：指针和指针相减得到的是两个指针相距之间元素的个数
5.指针和数组
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}
我们不难发现打印数组的地址和数组首元素的地址是一样的；
结论：数组名表示的是数组首元素的地址
那我们就可以用指针来访问数组
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
6.二级指针
指针变量也是变量，是变量就有地址，存放指针变量的地址就是二级指针；
int main()
{
int a = 10;
int* p = &a;//p是一个一级指针指向a
int** ppa = &p;
//int * 表明*ppa是一个指针指向p,而p也是一个指针因此ppa存放着一个指针的地址是一个二级指针
printf("%d\n", a);
**ppa = 30;//*(*ppa)得到p的地址即*(p)在对其解引用等价于a=30
printf("%d\n", a);
return 0;
}
二、指针进阶
目录
一、指针初阶
1.指针是什么
2.指针和指针类型
2.1指针
2.2指针的类型
2.3指针加减整数
2.4指针的解引用
3.野指针
3.1野指针的成因
3.2 如何在写代码的过程中规避野指针
4.指针运算
5.指针和数组
6.二级指针
二、指针进阶
1.字符指针
2.指针数组
3.数组指针
3.1数组指针的定义
3.2&数组名VS数组名
4.函数指针
5.函数指针数组
6.指向函数指针数组的指针
1.字符指针
在上面我们知道指针是有一种指针类型为char *
基础使用方法：
int main()
{
char ch = 'w';
printf("%c\n", ch);
char* pc = &ch;
*pc = 'a';
printf("%c\n", ch);
return 0;
}
进阶用法：
int main()
{
const char* p = "abcdef";//双引号引用的 常量字符串 不可改变
//字符串表达式 将首字符a的地址交给p
printf("%s\n", p);//abcdef
printf("%c\n", *p);//a
return 0;
}
上面的代码是将常量字符串abcdef中的首字符a放在了字符指针变量p中
2.指针数组
指针数组这个名词看起来很蒙圈，其实它是一个数组只不过数组中的每个元素为指针；
实例：使用指针数组模拟实现二位数组
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* arr[3] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
//printf("%d ", *(arr[i] + j));
}
printf("\n");
}
return 0;
}
上面这个例子只是模拟实现 二维数组，并不是二维数组真正实现的样子，大家不要混淆了。
3.数组指针
3.1数组指针的定义
那数组指针到底是数组还是指针呢？
答案：指针
int *p1[10];
//[]的结合性高p1先和[]结合表明是一个数组，数组中的每个元素为int *所以叫指针数组
int (*p2)[10];
//p2先和*结合表明是一个指针，然后指向一个大小为10个整形的数组 p2是一个指针 所以叫数组指针实例：用数组指针模拟实现二维数组
void print(int(*p)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", *(*p + i) + j);
//printf("%d ", (*p + i)[j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
int(*p)[5] = &arr;
print(p, 3, 5);
return 0;
}
上面数组指针的实例和指针数组的实例一样只是模拟实现二维数组，并不是二维数组真正的实现方式，请大家不要混淆。
3.2&数组名VS数组名
我们知道arr是数组名，数组名表示数组首元素的地址。
那么&arr数组名到底是啥？
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}
我们不难发现两个地址是一样的；那么两个表示的意思究竟一样不？
让我们在看一段代码
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
return 0;
}
根据上面的代码我们发现arr和arr+1相差4，而&arr和&arr+1相差40，所以arr和&arr虽然值是一样的，但意义不一样。
实际上：&arr取的是整个数组的地址，而不是首元素的地址。数组的地址+1，是跳过整个数组的大小，所以&arr和&arr+1相差40
4.函数指针
让我们先看一段代码
int test()
{
return 0;
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
通过上面的代码我们发现其实函数也是有地址的，所以我们也可以用一个指针变量来存储函数的地址，写法是这样的
int (*p)()
//表示p是一个指向返回值为int类型，没有参数的函数指针5.函数指针数组
函数指针数组是一个数组，数组中的每个元素为函数指针；
写法是这样的
int (*p[])()
//p先和[]结合表示是一个数组，数组中的每个元素 ( int(*)() ) 为返回值为int，参数为空的函数指针
函数指针数组的用途：转移表
实例：利用函数指针数组实现整数的加减乘除的计算器
int add(int x, int y)
{
return x + y;
}
int sub(int x, int y)
{
return x - y;
}
int mul(int x, int y)
{
return x * y;
}
int div(int x, int y)
{
return x / y;
}
void meun()
{
printf("******************\n");
printf("***1.add 2.sub ***\n");
printf("***3.mul 4.div ***\n");
printf("*** 0.exit ***\n");
printf("******************\n");
}
int main()
{
int ret = 0;
int input = 0;
int(*p[5])(int x, int y) = { NULL,add,sub,mul,div };
int x = 0; int y = 0;
do
{
meun();
printf("请选择>:\n");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两个操作数>:\n");
scanf("%d %d", &x, &y);
ret=(*p[input])( x, y);
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出\n");
}
else
{
printf("选择错误，请重新选择\n");
}
} while (input);
return 0;
}
6.指向函数指针数组的指针
首先它是一个指针指向的是一个数组，数组中的每个元素为函数指针；
定义为：
int test(int a)
{
return a;
}
int main()
{
int (*p1)(int) = &test;
//p1先于*结合表明是一个指针，指向( int ( )( ) )返回值为int类型的test函数
int (*p2[2])(int) = { NULL,test };
//p2先于[]结合表明是一个数组，
//数组中的每个元素( int(*)(int) )为指向返回值为int，参数为int类型的指针
int (*(*p3)[2])(int) = &p2;
//p3先于*结合表明是一个指针，指向(int (*[])(int))数组
//数组中的每个元素( int(*)(int) )为指向返回值为int，参数为int类型的指针
return 0;
}