文章目录
前言
指针是c语言的重中之重
（一）指针初阶：
一 : 什么是指针
其实指针有两层含义:
1.指针是地址是一层含义
2.当地址或者指针需要存起来的时候，我们需要一个指针变量，这个指针变量是存放地址的，我们经常说的“指针“，”指针“,其实是指针变量，指针变量也被称为指针
二 : 什么是野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
简单的说：你在大街上看见一条狗，那个狗没有栓链子，没有主人，我们称它为野狗，指针也是一样，不知道指向内存的什么地址,就被称为野指针。
什么情况下会造成野指针呢?
1 . 指针未初始化
#include <stdio.h>
int main()
{
int* p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
上面的代码意思可以理解为：你看见了一个酒店，你进去了，随便找了个房间就睡觉了，并没有去前台取得自己的一个房卡。
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;
}
return 0;
}
这里画一个图表示一下：
arr数组就给了10个空间，只到下标九，但是上面的for循环循环了11次，可以得出已经访问超过我们的arr数组大小了所以会出现指针越界访问的情况。
3 . 指针指向的空间释放
int* test()
{
int a = 10; //（1）第一次进来创建a 出去test函数 空间给操作系统
return &a;
}
int main()
{
int *p= test();
*p = 20; //（2）还是第一次的地址 ，但是出来了第一次的地址已经还回去了，
//（3）这时候进行赋值，会造成非法访问 p野指针
return 0;
}
来个例子：你和你女朋友分手了，但是你还有女朋友的电话，你就三番两次打电话给她，但是她已经不是你女朋友了，你这样就属于非法骚扰了…
如何避免野指针
1.指针初始化
要养成好的编程习惯，当变量不知道赋什么的话，可以先赋个0，或者相对应类型的值 int a = 0；
指针不知道应该初始化成什么值的时候，建议直接初始化为NULL。
#include <stdio.h>
int main()
{
int* p = NULL; //NULL要引用头文件
return 0;
}
2.小心越界
C语言本身不会检查数组的越界，要我们自己保存头脑清晰
3.指针指向的空间释放及时置NULL
要使用的代码被释放了，及时置NULL
4.指针使用之前检查有效性
先来看看下面的代码可以运行起来不？
int main()
{
int* p = NULL;
*p = 10;
return 0;
}
答案是：不可以的，为什么呢？
NULL其实是一个地址位置是在0处的一个地址，这个地址在操作系统里，没有分配给用户，所以不可以把10放进去赋值。
那么怎么规避呢？可以在使用之前先判断一下
int main()
{
int* p = NULL;
if (p!= NULL) //不是空才继续使用，增加代码的健壮性
{
*p = 10;
}
return 0;
}
上面的方法讲完就不会遇见野指针了吗？其实不然，你要写BUG谁也难不住，教的是怎么避免少写，养成好习惯！！！
三 : 指针的运算
- 指针± 整数
- 指针-指针
- 指针的关系运算
1.指针的加减整数运算
代码包含指针加减整数和指针的关系运算
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
上面的代码大家可以试着看一下，下面有解析：
解析：
定义了一个值为5
定义了一个数组长度为5，下面是名为values的数组
指针变量 vp
for (vp = &values[0]; vp < &values[N_VALUES] ; )
{
*vp++ = 0;
}
vp < &values[N_VALUES] 小于第5个元素
*vp++ = 0;
vp指向的是第一个数组下标为0的，条件是小于数组第5个元素就停止，所以最后代码全部运行起来，就是把数组0-4的下标全部赋为0
随着数组下标的增长， 地址其实是由低到高变化的
2.指针 - （减）指针
问：下面代码显示的是什么？
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n",&arr[9] -&arr[0]);
return 0;
}
答案：9
解析：
指针减指针 得到的两个指针之间的元素个数
指针和指针相减的前提是：两个指针指向的同一个空间
&arr[9] 和&arr[0] 分别指向的是，他们之间有9个元素，所以是9
指针和指针相减的前提是：两个指针指向的同一个空间
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
char c[5];
printf("%d\n",&arr[9] -&c[0]);//e
return 0;
}
上面代码块是错误的。
3.使用指针减指针模仿写一个strlen
我们都知道指针减指针就可以得到元素个数，那么来看一下接下来的模仿strlen函数的思路吧！
找到a的地址，和 \0的地址（每一个字符串后面都有一个隐藏的\0），让它们相减就可以求出字符串的长度了
下面放代码：
int my_strlen(char* str)
{
char* start = str; //保存一开始的地址 start 里面是 a的地址
while (*str != '\0') // 如果str不会最后一个\0就不会停下来
{
str++; //一直加到\0
}
return str - start; // '\0' - 'a' 指针减指针
}
int main()
{
int a = my_strlen("abc");
printf("%d\n",a); // 打印3
return 0;
}
四 : 指针和数组
想学好指针，你必须先知道数组名是什么！！
数组名是数组首元素地址
代码来验证一下：
int main()
{
int arr[10] = { 0 };
printf("%p\n",arr); //数组名是首元素地址
printf("%p\n",&arr[0]); //取第一个元素的地址
return 0;
}
果然地址是一样的！
那么数组名是一个地址，是不是也可以拿指针来接收
int arr[10] = { 0 };
int* p = arr;
看下面的代码：
既然arr是首元素地址 ,但是可以拿p指针来接收, 是不是 （arr == p)呢?
跑一下下面的代码：
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for ( i = 0; i < 10; i++)
{
printf("%p <==> %p <==> %p \n",&arr[i] , p+i ,arr+i);
//p+i 访问第i个元素地址
}
return 0;
}
结果：好家伙3个地址一模一样，所以上面的问题是成立的
有了上面的例子，我们可以推导出来一个更加有趣的代码例子：
(加法支持加法交换律)
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int* p = arr;
arr[2] <==> *(arr+2) <==> *(2+arr) <==> 2[arr]
*(p+2) <==> *(2+P) <==> 2[p] <==> p[2]
以上都是可以支持打印出来正确的数字，但是为什么呢?
[ ]是一个操作符 arr[ 2] , arr 和 2 是两个操作数
其实 arr [ 2 ] 这种写法编译器最终会把它转换为 *(arr+2) ，arr表首元素地址 加上2 就是跳过2个元素 解引用就得到最终的结果了
五 : 二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
看看下面代码：
int main()
{
int a = 10;
//为什么要int*呢
int *pa = &a; //a是int类型 *pa表示pa是个指针变量 所以是int*
int* *ppa = &pa; //int* 是因为pa是int*类型 *ppa 表示ppa是个指针
return 0;
}
有个a变量，在内存开辟一个内存空间，地址是0x11223344
int a = 10;
int* pa = &a;
把a的地址放在pa的内存空间里面。 pa的地址是0x44332211
int** ppa = &pa;
把pa的地址放在ppa的内存空间里面。 ppa的地址是0x22334411
为什么叫二级指针呢，因为指向的有两层关系，比如我现在要修改 a 的值要怎么修改呢?
**ppa == *(pa) == 把pa解引用 自然可以修改到值
六 : 指针数组
指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
int arr1[5]： 整形数组 -存放整形的数组就是整形数组
char arr2[6]： 字符数组 - 存放的是字符
int* arr3[5]：整形指针数组： arr3是一个数组，有五个元素，每个元素是一个整形指针。
（二）指针进阶：
一 : 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char*， 一般是这样使用的：
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
还有一种使用方式如下： 把字符串放在字符指针变量中。
int main()
{
char* pstr = "hello world";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}
那么出现一个问题：char* 就算是在64位的机器是最多也是存8个字节啊，把hello world放进去可以放的下吗？
其实：关于上面的问题，解释是：本质上是把字符串的首字符地址存储在了pstr中，可以代码验证一下：如果是第一个字符那打印出来的是 h
果然一模一样！！
来一个练题：
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
char* str3 = "hello bit.";
char* str4 = "hello bit.";
if (str1 == str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if (str3 == str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}
输出什么？
答案:
为什么呢？来看下面的解析
首先我们可以看到可以有4个变量，先看一下str1 和str2 .
它们是两个不相同的数组，所以分别指向不同的地址。
来看看str3和str4，因为str3 和str4存放的是常量字符，常量字符是不可以被改变的，所以在内存存放的是同一个内容，2个变量同时指向同一个地址一起使用，所以应该是下图所示：
所以最后就是上面的那个结果，对于这道题目的最大争议就是 str3 和str4存的变量是不是常量变量不可以被修改，我们可以去编译器看一下：
可以看见这里是报错的，所以说我们上面所述的如实。
二: 指针数组
指针数组本质上是数组，数组中存放的是指针（地址）
应用场景：
int main()
{
int a[3] = { 1,2,3 };
int b[] = { 4,5,6 };
int* c[3] = {a,b};
int i = 0;
for ( i = 0; i < 2; i++)
{
int j = 0;
for ( j = 0; j < 3; j++)
{
printf("%d ",c[i][j]);
}
printf("\n");
}
return 0;
}
三 : 数组指针
数组指针是指针？还是数组？
答案是：指针。
下面代码哪个是数组指针？
int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？
解释：
p1是指针数组
p2是数组指针，
解释：p2先和结合，说明p2是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于号的，所以必须加上（）来保证p先和*结合
&数组名VS数组名
对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：
#include <stdio.h>
int main()
{
int arr[10] = {0};
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr= %p\n", &arr);
printf("arr+1 = %p\n", arr+1);
printf("&arr+1= %p\n", &arr+1);
return 0;
}
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
数组名是数组首元素的地址
但是有2个例外：
1.sizeof（数组名） - 数组名表示整个数组，计算的是整个数组的大小，单位是字节
2.&数组名 - 数组名表示整个数组 ，取出的是整个数组的地址
四 : 一维数组传参、二维数组传参
数组的传参，使用以下形式都可以
（1）：一维数组传参
#include <stdio.h>
void test(int arr[])//ok
{}
//不在[]里面写10，是因为传过来的是首元素地址，并不会真的开辟一个10个数组的大小，可省，写了也不影响
void test(int arr[10])//ok
{}
//同上
void test(int *arr)//ok
{}
//传过来的是首元素地址，所以可以拿1级指针。
void test2(int *arr[20])//ok
{}
void test2(int **arr)//ok
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}
这里解释一下为什么 void test2(int **arr) 也可以：
arr里面的类型都是1级指针，所以放在2级指针存放没有什么不合适。
（2）：二维数组传参
二维数组，首元素是第一行地址
void test(int arr[3][5])//ok
{}
//实参是2维数组，
void test(int arr[][])//no
{}
//可以省略行，不可以省略列
void test(int arr[][5])//ok
{}
//只省略了行，没有省略列
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//no
{}
//这个是传过来第一行的地址
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
//arr是一个指针，指向的是5个int类型，实参传过来的是首元素地址，也就是第一行地址，第一行地址是int类型，所以可以
void test(int **arr)//ok
{}
//因为传过来的压根不是首元素地址，是第一行地址，是一维数组的地址，所以不可以拿二维指针接收。
int main()
{
int arr[3][5] = {0};
test(arr);
}
（3）：一级指针传参
#include <stdio.h>
void print(int *p, int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
printf("%d\n", *(p+i));
}
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9};
int *p = arr;
int sz = sizeof(arr)/sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：
void test1(int *p)
{}
int a = 10;
int* pa = &a;
//test1函数能接收什么参数？
//答： test1(&a); test1(a);
void test2(char* p)
{}
char a='w' ;
char* pa = &a;
//test2函数能接收什么参数？
//答： test2(&a); test2(a);
（4）：二级指针传参
列：
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n;
int **pp = &p;
int * arr[10] = {0};
test(pp); //传二级指针变量 可以
test(&p);//传一级指针变量的地址 可以
test(arr);//传存放一级指针的数组 可以
return 0;
}
五 : 函数指针
函数指针：指向函数的指针！ 存放函数地址的指针。
先看一段代码： 打印test函数的地址，和取地址打印test函数的地址，它们一样吗？
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
看结果：发现他们的地址都是一样的。
现在出来一个结论：
数组 arr != &arr
一个是数组首元素的地址 和整个数组的地址
函数 test == &test
函数不存在什么首元素地址，函数名即是取函数地址
问：那我们的函数的地址要想保存起来，怎么保存？来个列子：
int add(int x, int y)
{
return x + y;
}
int main()
{
int ret = add(3, 5);
int (*pret) (int, int) = &add; //存放函数的指针
//返回类型 (*变量名) (函数类型)
int prt1 = (*pret)(3, 5);
int prt2 = pret(3,5);
int pt = add(3, 5); //ok 通过函数名
printf("%d\n", prt1); // ok
printf("%d\n", prt2); //ok
printf("%d\n", pt); //ok
return 0;
}
上面代码输出结果：
上面那么多代码：其实发现prt1 和 prt2 一个加了*，一个没有加*，但是结果都是一样的，其实那颗* 是一个摆设，只是让我们更加好理解，你前面也可以加5颗* ，最后的结果是一样的 。
函数指针语法：
返回类型 ([*]变量名) (函数类型)
自己尝试写写下面列子:
void test(char* str)
{
}
int main()
{
pt = &test; //pt该怎么写？
return 0;
}
结果：void (*pt) (char*)
阅读两段有趣的代码：请读懂这两段代码的意思？
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
解析代码1：（整个代码的意思是：调用了0地址处的函数，该参数返回类型是void） ，一步一步来看：
（1）void (*)() 是一个函数指针类型：
（2）( void (*)() ) 0 :把0强制转换类型，被解释是一个函数地址
（3）(* void (*)() ) 0 :对0地址处进行了解引用操作
（4）(* void (*)() ) 0() :调用了0地址处的函数
本题出自:《C陷阱和缺陷》
解析代码2：整个代码是 函数参数的声明
void (signal(int , void()(int)))(int);
把这个代码拆分开，好理解点
（1）signal先和( )结合,说明signal是函数名
（2）signal函数的第一个参数是int类型，第二个参数是函数指针，
该函数指针，指向一个参数为int，返回类型是void
（3）signal函数的返回类型也是一个函数指针
该函数指针，指向一个参数为int，返回类型是void
singal是一个函数声明
代码2太复杂，如何简化：其实我们可以把 void(*)(int) 这个类型，使用typedef
typedef void(*pfun_t)(int);
简化前: void (signal(int , void()(int)))(int);
简化后：pfun_t signal(int, pfun_t);
六 : 函数指针数组
我们都知道数组是存放同类型数据的存储空间，那我们已经学习了指针数组， 比如：int arr[10]; //数组的每个元素是int
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])()
怎么理解这个代码：首先parr1先和[ ]结合说明是一个数组
int (*)()
去掉中间的内容，就是int (*)()类型的函数指针。
问：那么函数指针数组有什么用呢？ 函数指针数组的用途：转移表
使用案列：未使用函数指针数组，代码冗余
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a * b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}
使用案列：使用函数指针数组，代码简洁
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 menu()
{
printf("************");
printf("***1.ADD***\n");
printf("***2.SUB***\n");
printf("***3.MUL***\n");
printf("***4.DIV***\n");
printf("***0.exit***\n");
}
int main()
{
int input = 0;
int ret = 0;
int x, y;
int(*pfArr[5])(int , int ) = { NULL, add,sub,mul,div};
do
{
menu();
printf("请选择菜单");
scanf("%d", &input);
if (input>=1 && input<= 4)
{
printf("请输入2个数字");
scanf("%d %d",&x , &y);
ret = (*pfArr[input])( x , y); //找到执行函数的地址，必须要参数一样的才可以这样使用。
printf("ret = %d\n", ret);
}
else
{
printf("输入错误\n");
}
} while (input);
return 0;
}
七 : 指向函数指针数组的指针
指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针
int(*P) (int, int) //函数指针
int(*P2[5]) (int, int) //函数指针数组
int(*p(*P3)[5])(int ,int ) =&p2 ;//指向函数指针数组的指针
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[10])(const char*) = &pfunArr;
return 0;
}
这部分做个了解，不必太深入。
七 : 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
还是上面的 计算器代码：
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;
}
int calu(int(*(*pf)(int,int))) //把函数地址当参数
{
int x, y;
printf("输入操作数：");
scanf("%d %d", &x, &y);
return (*pf)(x, y);
}
int main()
{
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
ret = calu(add); //把函数地址传过去
printf("ret = %d\n", ret);
break;
case 2:
ret = calu(sub);
printf("ret = %d\n", ret);
break;
case 3:
ret = calu(mul);
printf("ret = %d\n", ret);
break;
case 4:
ret = calu(div);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}