指针
前言
想必对于很多刚接触C语言的同学来说关于指针的知识点很头疼，就感觉跟树枝一样错综复杂，最终搞得自己不知道指针该指向哪里，此片文章就对指针做一个详细介绍，希望能够帮到你！
一、指针
1.什么是指针？
在计算机科学中，指针是编程语言中的一个对象。指针是内存地址，指针变量是用来存放内存地址的变量，利用内存地址可以直接指向存在电脑存储器中的那块内存单元，从而能找到所需的变量单元，也就是说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。
#include <stdio.h>
int main()
{
int a = 10; //在内存中开辟一块空间
int *p = &a; //这里我们对变量a，取出它的地址，可以使用&操作符。
//将a的地址存放在p变量中，p就是一个指针变量。
return 0;
}
总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那有的人就说指针不是地址吗？怎么又成变量了。
这就相当于对于你自己来说，你的名字就可以代表你自己，别人提到你的名字就知道是你，你的名字代表你，而指针变量代表地址。
在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以指针的大小在32位平台是4个字节，在64位平台是8个字节。
2.指针类型
我们都知道变量有不同的类型：整型、浮点型等等，同样的对于指针变量来说也有相应的类型。
int num = 10;
int* p = #
将&num（num的地址）保存到p中，p就是一个指针变量，它的类型就为 int*
char* pc = NULL;
int* pi = NULL;
short* ps = NULL;
long* pl = NULL;
float* pf = NULL;
double* pd = NULL;
指针的定义方式是： type* 。 其实： char* 类型的指针是为了存放 char 类型变量的地址， short* 类型的指针是为了存放 short 类型变量的地址， int* 类型的指针是为了存放int 类型变量的地址。
#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);
return 0;
}
- &n、pc、pi 都表示了变量 n 所占内存空间的起始地址，为00C2FB6C
- 在定义 pc 指针变量时将其强制转化为 char* 类型，那么对其进行 +1 操作时指针向后移动一个字节，为00C2FB6D
- 对 pi 指针变量进行 +1 操作则指针向后移动四个字节，为002CFB70
指针类型的意义：
1.指针类型决定了指针进行解引用操作的时候，能访问空间的大小，比如： char* 的指针解引用就只能访问一个字节，而 int* 的 指针的解引用就能访问四个字节。
2.指针类型决定了指针的步长(指针走一步可以走多远)。
字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char*
int main()
{
char ch = 'w';
char *pc = &ch; //pc就为字符指针
*pc = 'w';
return 0;
}
int main()
{
char* pstr = "hello world.";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}
代码 char* pstr = “hello world.”; 特别容易让同学以为是把字符串 hello world. 放到字符指针 pstr 里了，但是本质是把字符串 hello world. 首字符的地址放到了pstr中。
二、指针运算
1.指针±整数
int main()
{
int arr[5] = { 0 };
for (int i = 0; i < 5; i++)
{
*(arr + i) = i;
}
for (int i = 0; i < 5; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
在 arr 数组当中，每个元素类型为 int 型，在每次 arr+i 时指针都会从数组的起始位置向后移动（ i * 4）个字节，若元素类型为 char 型，则 arr+i 指针会向后移动 i 个字节。
2.指针-指针
int my_strlen(char *s)
{
char *p = s;
while (*p != '\0')
p++;
return p - s;
}
int main()
{
char str[] = "abcdef";
int ret = my_strlen(str);
printf("%d\n", ret);
return 0;
}
从输出结果可以知道指针与指针的差值为两者之间的元素个数，结果与元素类型没有关系。
3.指针的关系运算
for(n = &arr[num-1]; n >= &arr[0];n--)
{
*n = 0;
}
从上面的代码可以看到指针 n 指向 arr 数组的最后一个元素，每次循环 n 都向前移动并与数组第一个元素的地址进行比较，最终跳出循环指针 n 的指向为 arr 数组的首个元素前的那个内存位置的地址。实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
三、野指针
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的），指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。
1.野指针成因
1.1指针未初始化
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
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;
}
return 0;
}
1.3指针指向的空间释放
#include <stdio.h>
#include <malloc.h>
int main()
{
int *p = (int*)malloc(sizeof(int));
free(p); //释放掉指针p所指向的内存空间后，就不能在对其解引用访问这块空间，
//尽管p的内容依然是那块内存空间
p = NULL;
*p = 10;
printf("%d\n", *p);
return 0;
}
对于该知识点讲一个小故事：你的手机里存着你女朋友的电话号码，每天就可以给她打电话，但有一天你们分手了，没有了任何关系，但是你的手机现在依然存着你女朋友的电话号码，你说我还是要和她打电话，那么你女朋友就可以报警说你骚扰她，这就造成了非法访问。
四、指针数组与数组指针
1.指针数组
指针数组是一个存放指针的数组。
int* arr[5];
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
2.数组指针
从名字我便可知，数组指针是一个指针，它指向一个数组。（指向数组的指针）
int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？
int (*p)[10];
p先和 * 结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意：[] 的优先级要高于 * 号的，所以必须加上（）来保证p先和 * 结合。
2.1 &数组名VS数组名
对于一个数组来说，数组名代表着它的首元素地址，那么 &数组名 是是什么呢？
看一下这段代码：
#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 的差值是4，数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
2.2数组指针的使用
void print_arr(int (*arr)[5], int row, int col)
{
int i = 0;
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print_arr(arr, 3, 5);
return 0;
}
五、数组参数、指针参数
1.一维数组传参
#include <stdio.h>
void test(int arr[])// true
{}
void test(int arr[10])// true
{}
void test(int *arr)// true
{}
void test2(int *arr[20])// true
{}
void test2(int **arr)//true
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr); //传递一维数组,传递首元素地址，形参可以是数组，也可以是指针
test2(arr2);// 每个元素都是 int* 类型
}
2.二维数组传参
void test(int arr[3][5])// true
{}
void test(int arr[][])// false
{}
void test(int arr[][5])// true
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
void test(int *arr)// false
{}
void test(int* arr[5])// false
{}
void test(int (*arr)[5])// true
{}
void test(int **arr)// false
{}
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;
}
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
int a = 10;
test(&a);
int* p = &a;
test(p);
int arr[5];
test(arr);
4.二级指针传参
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n;
int **pp = &p;
test(pp);
test(&p);
return 0;
}
当函数的参数为二级指针的时候，可以接收什么参数？
char c = 'b';
char* pc = &c;
test(&pc);
char** ppc = &pc;
test(ppc);
char* arr[10];
test(arr);
六、函数指针
指向函数的指针
#include <stdio.h>
void add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", add);
printf("%p\n", &add);
int (*p)(int x,int y) = &add; // p 为函数指针变量，函数的地址便可存放在 p 指针中
return 0;
}
输出的是两个地址，这两个地址是 test 函数的地址。
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
代码1：首先在内部 void (*) () 是一个函数指针，将其放在整数 0 的前面意味着对其强制类型转换为函数指针类型。所以整体意思是调用首地址为 0 位置的函数，它的参数为无参。
代码2：这是一个函数声明，声明的函数名为 signal，参数有两个，第一个参数为 int ，第二参数为函数指针，指向一个函数，函数参数是 int ,返回值类型为 void 型，而 signal 函数的返回类型是一个函数指针，指针指向一个函数，函数参数是 int ,返回值类型为 void 型。
//对代码进行简化处理
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);
七、函数指针数组
首先函数指针数组是一个数组，里边存放的元素为函数指针
int (*func[10])(int, int)
//func首先和[]结合，说明是一个数组，数组10个元素，而剩下的表示数组元素的类型（函数指针类型）
函数指针数组的用途：转移表
接下来写一个简单的计算器
#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");
breark;
default:
printf( "选择错误\n" );
break;
}
} while (input);
return 0;
}
现在在这个运算当中只有四个（加减乘除），但是若要给其中在添加一些其他的运算，功能越复杂，在下面 case 语句就越来越多，那么我们就可以使用函数指针数组进行简化，因为所有函数的操作数、返回值都相同，将所有的函数地址可以存放到数组当中，通过你自己的选择在数组中选择对应坐标处的函数进行调用。
int main()
{
int x, y;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
while (input)
{
printf( "*************************\n" );
printf( " 1:add 2:sub \n" );
printf( " 3:mul 4:div \n" );
printf( "*************************\n" );
printf( "请选择：" );
scanf( "%d", &input);
if ((input <= 4 && input >= 1))
{
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = (*p[input])(x, y);
}
else
{
printf( "输入有误\n" );
}
printf( "ret = %d\n", ret);
}
return 0;
}
八、指向函数指针数组的指针
指向函数指针数组的指针是一个 指针，指针指向一个 数组 ，数组的元素都是 函数指针 ;
//函数指针
int (*pf)(int, int);
//函数指针数组
int (*pfArr[5])(int, int);
//指向函数指针数组的指针
//int(*(*ptr)[5])(int, int) = &pfArr;
开个玩笑，你也可以将该指针存放到数组当中，进行无限套娃。
九、回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
对于回调函数的使用可以看一下 qsort 函数的使用：链接: http://t.csdn.cn/N11rG