【C语言】进阶指针
一、字符指针
例如下面代码，pc就是一个字符指针；"abcdef"是一个常量字符串，不能被修改，pb里面存的是该常量字符串的首字符’ a '的地址。
int main()
{
char ch = 'w';
char *pc = &ch;
char *pb = "abcdef";
*pc = 'w';
return 0;
}二、指针数组
首先，先来回忆一下数组的类型： 字符数组----存放字符的数组char arr[5]; 整型数组----存放整型的数组int arr[5];
所以，可以理解指针数组就是存放指针的数组； 存放字符指针的数组----字符指针数组char* arr[5]; 存放整型指针的数组----整型指针数组int* arr[5];
例如，下面代码int* arr[]是个整型指针数组；
int main()
{
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int* arr[] = { &a,&b,&c,&d };
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", *(arr[i]));
}
return 0;
}三、数组指针
1.定义
整形指针 - 指向整型的指针
int a = 10;
int* p = &a; 字符指针 - 指向字符的指针
char ch = ' w ';
char* pc = &ch;数组指针 - 指向数组的指针；&arr取出的是整个数组的地址，pa首先和 * 结合是指针，这个指针指向大小为10的数组，数组中元素的类型是int.
[ ]的优先级要高于 * 号的，所以必须加上（）来保证p先和*结合。
int arr[10];
int (*pa)[10] = &arr; 2. &arr和arr
数组名绝大部分情况下是数组首元素的地址 但是有2个例外： （1） sizeof(数组名) - sizeof内部单独放一个数组名的时候，数组名表示的整个数组，计算得到的是数组的总大小 （2） &arr - 这里的数组名表示整个数组，取出的是整个数组的地址,从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样
任何时候看到数组名都要先判断是不是上面两种例外，因为这会影响指针走的步长；例如下面代码：arr + 1和&arr[0] + 1都是向后跳过4个字节，它们的类型都是int*.
而&arr 的类型是： int(*)[10] ，是一种数组指针类型；数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr); //int *
printf("%p\n", arr+1); //4
printf("%p\n", &arr[0]); //int*
printf("%p\n", &arr[0]+1); //4
printf("%p\n", &arr); //int(*)[10]
printf("%p\n", &arr+1); //40
int (*p)[10] = &arr; //p是一个数组指针
//int(*)[10]
return 0;
}3. 数组指针的应用
参数是数组的形式
void print1(int arr[3][5],int x ,int y)
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}参数是指针的形式
以下四种等价： printf("%d ", p[ i ][ j ]);
printf("%d ", * ( p[ i ] + j)); //p[i]是第i行首元素的地址，加上j跳过一个整型，即找到下一个元素的地址，解引用就是下一个元素
printf("%d ", * (* (p + i)+ j )); //*(p + i)找到这一行的地址
printf("%d ", ( * (p + i ))[ j ]);
void print2(int(*p)[5], int x, int y)
{
int i = 0;
for (i = 0; i < x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
//以下四种等价
//printf("%d ", p[i][j]);
//printf("%d ", *(p[i] + j));
//printf("%d ", *(*(p + i)+j)); //*(p + i)找到这一行的地址
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} };
print1(arr,3,5);
printf("\n");
print2(arr, 3, 5);
return 0;
}注意：数组名arr，表示首元素的地址，但是二维数组的首元素是二维数组的第一行，所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址，可以用数组指针来接收；这里二维数组的初始化要用两个{}初始化.
解读代码：
int arr[5]; arr是一个5个元素的整型数组
int* parr1[10]; parr1是一个数组，数组有10个元素，每个元素的类型是int，parr1是指针数组
int(*parr2)[10]; parr2是一个指针，该指针指向了一个数组，数组有10个元素，每个元素的类型都是int，parr2是数组指针
int(*parr3[10])[5];（[]的优先级比*高，所以parr3先和[]结合成数组）parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，该数组指针指向的数组有5个元素，每个元素是int四、数组传参和指针传参
1. 数组传参
（1）一维数组传参（以下都可以）
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int* arr)
{}
void test2(int *arr[20])
{}
void test2(int **arr)
{}
int main()
{
int arr[10] = { 0 };
int arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
}（2）二维数组传参（以下都可以）
二维数组传参，如果用指针接收，传过去的是第一行的地址，形参就应该是数组指针.
void test(int arr[3][5])
{}
void test1(int arr[][5])
{}
void test2(int (*arr)[5])
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);//二维数组传参
test1(arr);
return 0;
}2. 指针传参
二级指针传参（以下都可以）
void test(char ** p)
{}
//以下的都可以传上来
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);
return 0;
}五、函数指针
函数指针：指向函数的指针（存放函数地址的指针） 其中，函数名和&函数名都是函数的地址，没有区别.
（1）下面的int (*pa)(int, int)就是一个函数指针，pa先和 * 结合成一个指针，指针指向一个函数，函数类型都是int，返回类型是int；其中int( * )(int,int)是一个函数指针类型；
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
printf("%p\n", &Add); //&函数名和函数名都是函数的地址
printf("%p\n", Add);
int (*pa)(int, int) = Add; //把Add函数的地址存到pa里面去（指针指向一个函数，函数类型是int，返回类型是int）
printf("%d\n", (*pa)(2, 3)); //调用函数
return 0;
}（2）
void Print(char* str)
{
printf("%s\n", str);
}
int main()
{
void (*p)(char*) = Print; //把Print函数的地址存到p里
(*p)("hello world"); //调用函数
return 0;
}（3）解读代码：
代码1：void(* signal(int, void(*)(int)))(int);
signal是一个函数声明； signal函数的参数有两个，第一个是int，第二个是函数指针，该函数指针指向的函数参数类型是int，返回类型是void；； signal函数的返回类型也是一个函数指针，该函数指针指向的函数的参数是int，返回类型是void；
代码2：(* ( void (*)() ) 0)()；
这是一次函数调用； 将0强制类型转换为void (*)() 类型的函数指针； 这就意味着0地址处放着一个函数，函数没参数，返回类型是void； 调用0地址处的这个函数；
六、函数指针数组
1. 定义
把函数的地址存到一个数组中，那这个数组就叫函数指针数组，函数指针数组的定义：int (*parr1[10])( );首先parr1和[ ]结合成数组，数组的内容是int ( * )() 类型的函数指针.
2. 函数指针数组的应用 - 转移表
计算器
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 = 0;
int y = 0;
int (*p[5])(int x, int y) = { 0,add,sub,mul,div };
// 下标：0，1， 2， 3， 4
int input = 1;
while (input)
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("****** 0：exit ********\n");
printf("请选择：");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入两个数：\n");
scanf("%d %d", &x, &y);
int ret = p[input](x, y); //这里调用使用 (*p[input])(x, y)也可以
printf("%d\n", ret);
}
else
{
printf("输入有误，请重新输入\n");
}
}
return 0;
}七、指向函数指针数组的指针
ppfArr 是一个数组指针，指针指向的数组有四个元素； 指向的数组每个元素的类型是一个函数指针 int(* )(int ,int)；
int main()
{
int arr[10] = { 0 };
int(*p)[10] = &arr;
int (*pfArr[4])(int, int); //pfArr是一个数组--函数指针的数组
int (*(*ppfArr[4]))(int, int) = &pfArr; //ppfArr是一个指向函数指针数组的指针
return 0;
}八、指针和数组的练习
数组和指针：
数组 - 能够存放一组相同类型的元素,数组的大小取决于数组的元素个数和元素类型
指针 - 地址/指针变量 ,大小是4/8个字节
数组是数组，指针是指针，二者不等价
数组名是数组首元素的地址，这个地址就可以存放在指针变量中 我们就可以使用指针来遍历数组
数组名 大部分情况下数组名是数组首元素的地址 但是有2个例外：
sizeof(数组名) - 数组名表示整个数组，计算的是整个数组的大小 &数组名 - 数组名表示整个数组，取出的是数组的地址
只要是看见数组名，首先判断是不是上面两个例外；
1. 一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a)); // 16
//sizeof(a)就是数组名单独放在sizeof内部，计算的数组总大小，单位是字节
printf("%d\n",sizeof(a+0)); // 4/8
//a+0 是数组首元素的地址
printf("%d\n",sizeof(*a)); // 4/8
//首元素的地址
printf("%d\n",sizeof(a+1)); // 4/8
//a是数组首元素的地址 -- int*；a+1 跳过1个整型, 是第二个元素的地址
printf("%d\n",sizeof(a[1])); // 4
//一个整型的大小
printf("%d\n",sizeof(&a)); // 4/8
//&a - 取出的是整个数组的地址，但是数组的地址也是地址，是地址大小就是4/8字节
printf("%d\n",sizeof(*&a)); // 16
//四个整型的大小
printf("%d\n",sizeof(&a+1)); // 4/8
//&a --> int (*)[4]，&a+1 跳过一个数组
printf("%d\n",sizeof(&a[0])); // 4/8
//取出首元素的地址
printf("%d\n",sizeof(&a[0]+1)); // 4/8
//第二个元素的地址2. 字符数组
（1）char arr[] = { ‘a’,‘b’,‘c’,‘d’,‘e’,‘f’ };
printf("%d\n", strlen(arr));
//随机值，因为不知道\0的位置
printf("%d\n", strlen(arr + 0));
//随机值
//printf("%d\n", strlen(*arr));
//非法访问
//printf("%d\n", strlen(arr[1]));
//'b' - 98 当成地址，形参非法访问
printf("%d\n", strlen(&arr));
//随机值
printf("%d\n", strlen(&arr + 1));
//随机值
printf("%d\n", strlen(&arr[0] + 1));
//随机值
printf("%d\n", sizeof(arr));//6
printf("%d\n", sizeof(arr + 0));
//arr+0是数组首元素的地址 4/8
printf("%d\n", sizeof(*arr));
//*arr是首元素的，计算的是首元素的大小 1
printf("%d\n", sizeof(arr[1]));//1
printf("%d\n", sizeof(&arr));
//&arr是数组的地址 4/8
printf("%d\n", sizeof(&arr + 1));
//&arr + 1跳过一个数组后的地址，4/8
printf("%d\n", sizeof(&arr[0] + 1));
//4/8 第二个元素的地址（2）char arr[] = “abcdef”;//[a b c d e f \0]
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
//printf("%d\n", strlen(*arr));//err
//printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//6
//&arr - char (*)[7]
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8
printf("%d\n", sizeof(*arr));//*arr -是数组首元素 1
//arr[0] *(arr+0)
//int sz = sizeof(arr)/sizeof(*arr);
//int sz = sizeof(arr)/sizeof(arr[0]);
printf("%d\n", sizeof(arr[1]));//1
printf("%d\n", sizeof(&arr));
//数组的地址，是地址就是4 / 8
printf("%d\n", sizeof(&arr + 1));//4 / 8
printf("%d\n", sizeof(&arr[0] + 1));//4 / 8（3）char* p = “abcdef”;
printf("%d\n", strlen(p)); //6
printf("%d\n", strlen(p + 1)); //5
//p+1是'b'的地址
//printf("%d\n", strlen(*p));//err
//printf("%d\n", strlen(p[0]));//err
printf("%d\n", strlen(&p));//随机值
printf("%d\n", strlen(&p + 1));//随机值
printf("%d\n", strlen(&p[0] + 1));
printf("%d\n", sizeof(p));//4 / 8
printf("%d\n", sizeof(p + 1));
//'b'的地址，4/8
printf("%d\n", sizeof(*p));//1
printf("%d\n", sizeof(p[0]));
//*(p+0)--'a' 1
printf("%d\n", sizeof(&p));//
printf("%d\n", sizeof(&p + 1));
printf("%d\n", sizeof(&p[0] + 1));
//&p[0]+1是'b'的地址3. 二维数组
printf("%d\n", sizeof(a));//48
//a这个二维数组的数组名单独放在sizeof内部，计算整个数组的大小
printf("%d\n", sizeof(a[0][0]));
//第一行第一个元素，4个字节
printf("%d\n", sizeof(a[0]));//16
//a[0] 第一行的数组名，这时数组名单独放在sizeof内部了
//计算的是数组的大小，单位是字节，16
printf("%d\n", sizeof(a[0] + 1));//4
//a[0]不是单独放在sizeof内部，a[0]表示的首元素的地址，即第一行第一个元素的地址 - &a[0][0]
//a[0] + 1 是第一行第2个元素的地址 &a[0][1]
printf("%d\n", sizeof(*(a[0] + 1)));
//a[0][1] 大小是：4个字节
printf("%d\n", sizeof(a + 1));
//a作为二维数组的数组名并非单独放在sizeof内部,所以表示首元素的地址
//二维数组的首元素是第一行，这里的a就是第一行的地址--- int (*)[4]
//a+1是跳过第一行，指向了第二行
printf("%d\n", sizeof(*(a + 1)));//16
//*(a+1)-->a[1]
printf("%d\n", sizeof(&a[0] + 1));//4/8
//&a[0]是第一行的地址
//&a[0]+1是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16 a[1]
printf("%d\n", sizeof(*a));//16
//*a - 就是第一行
//*a -- *(a+0) -- a[0]
printf("%d\n", sizeof(a[3]));//16sizeof不会真的改变()内的值，不会真的实现（）内的表达式；
int a = 5;
short s = 11;
printf("%d\n", sizeof(s = a + 2));//2
printf("%d\n", s);//11