一、字符指针
例如下面代码，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]));//16
sizeof不会真的改变()内的值，不会真的实现（）内的表达式；
int a = 5; short s = 11; printf("%d\n", sizeof(s = a + 2));//2 printf("%d\n", s);//11
