//捋一捋 int *arr1[3]; //指针数组 //数组个数是3,元素是int指针类型的数据 int (*arr2)[3]; //数组指针 //指针，指向数组，且数组的类型是int类型，且元素个数为3 int* (*arr3)[3]; //数组指针 //指针，指向数组，数组元素是int*类型，且元素个数为3 int (*arr4[3])[3]; //数组指针指针 //指针，指向一个数组指针，数组指针的类型是int(*) [3] 指向数组且为为int类型，元素个数为3 ......

#include void test(int arr[])//ok? { }//int arr[] 接收就是以int * arr形式接收，因为*arr等价与 arr[] void test(int arr[10])//ok? { }//int arr[10] 同上在形参中都是一个整型指针，形参中的数组长度无意义 void test(int* arr)//ok? { } //整型指针接收数组名就是首元素地址也就是整型指针 void test2(int* arr[20])//ok? { } //int* arr[20]等价于 int* arr[]等价于int**arr 即二级指针 //而实参就是一个指向整型指针的指针也就是二级指针 void test2(int** arr)//ok? { } //二级指针接收 int main() {int arr[10] = { 0 }; int* arr2[20] = { 0 }; test(arr); test2(arr2); }

void test(int arr[3][5])//ok？ { }//二维数组传参二维数组接收 void test(int arr[][])//ok？ { } //error 不知道二维数组中一维数组中元素个数 void test(int arr[][5])//ok？ { } //可以省略行不能省略列 //总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。 //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。 //这样才方便运算。 void test(int *arr)//ok？ { } //error 二维数组的数组名就是首元素地址，即一维数组的地址， // 也就是数组指针，应该用数组指针接收 void test(int* arr[5])//ok？ { }//error,指针数组，实参是数组指针 void test(int (*arr)[5])//ok？ { }//实参为数组指针与形参类型相同 void test(int **arr)//ok？ { } //error int main() {int arr[3][5] = { 0}; test(arr); }

• 二维数组的数组名就是首元素地址，而二维数组的元素就是一维数组，所以数组名的类型就是数组指针。
• 当二维数组数组名传参，形参接收时，数组的行可以省略，列不能省略，如果省略了列，我们就无法知道当指针加减跳过几个字节。
  
  文章图片
  

#include void print(int *p, int sz)//一级指针传参，一级指针接收 {int i = 0; for(i=0; i; i++) {printf("%d\n", *(p+i)); } } //void print(int p[],int sz) //数组接收，也即一级指针接收，不提倡这样写 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型指针为例 void test(int* p) {} int main() { int x=0; int* px=&x; int arr[10]; test(&x); //整型地址 test(px); //一级指针 test(arr); //一维数组名，即首元素地址，int* return 0; }

void test(char** p ) {} int main() { char ch = 'c'; char* pc = &ch; char* *ppc = &pc; char* arr[3]; test(&pc); //一级指针的地址，即二级指针 test(ppc); //二级指针 test(arr); //数组名，首元素地址，首元素为一级指针，所以为二级指针 return 0; }

思考：
当函数的参数为二级指针的时候，可以接收什么参数？

#include void test() {printf("hehe\n"); } int main() {printf("%p\n",test); //函数名 就是函数地址 printf("%p\n", &test); //&函数名 也是函数地址return 0; }

void test() { printf("hehe\n"); } //下面pfun1和pfun2哪个有能力存放test函数的地址？ void (*pfun1)(); //函数指针类型 void *pfun2(); //函数，函数的返回值是void*

函数指针类型
指针都是有类型的
整型指针 int*
数组指针 int (*)[]
函数指针 返回值 （*）（参数....）

#include int Add(int x, int y) { return x + y; } int main() { int (*pf)(int, int) = Add; int sum = (*pf)(3, 5); //对函数指针解引用 printf("sum = %d", sum); sum = pf(3, 5); //因为 Add和&Add相同，即Add等价于 pf printf("sum = %d", sum); return 0; }

//代码1 (*(void (*)())0)(); //void (*)()为函数指针 //(void (*)())0 将0强制类型抓换成函数指针的地址 //(*(void (*)())0)() *地址，调用0地址处的这个函数 //函数的返回值空，参数为空

//代码2 void (*signal(int , void(*)(int)))(int); //void(*)(int) 函数指针，返回值void,参数int //void (*signal(int , void(*)(int)))(int) // signal是函数名 //返回值是void(*)(int) // 参数int 和函数指针 void(*)(int) //这是一个函数的声明

void (*signal(int , void(*)(int)))(int); //既然这个函数的返回值类型是 void(*)(int) //那我们可以写成 // void(*)(int) signal(int , void(*)(int)); //但是这样会语法错误 error

typedef void(*ptr_t) (int); //正确的类型重命名 ptr_t signal(int, ptr_t); //简化

int* arr[10]; //整型指针数组

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10]])(); // int *parr2[10](); int (*)() parr3[10];

答案是：parr1 ·parr1· 先和[] 结合，说明parr1是数组，数组的内容是什么呢？ 是int (*)()类型的函数指针。

#include 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 (*pf[4])(int, int) = { add,sub,mul,div }; int sz = sizeof(pf) / sizeof(pf[1]); int i = 0; for (i = 0; i < 4; i++) {//实现5和3的加减乘除 printf("%d\n", pf[i](5,3)); } return 0; }

//计算器优化 #include void menu() {printf("*************************\n"); printf("1:add2:sub\n"); printf("3:mul4:div\n"); printf("*************************\n"); printf("请选择："); } 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; } void Calc(int (*pf)(int ,int)) {int x, y; printf("请输入两个操作数\n"); scanf("%d%d", &x, &y); printf("%d\n", pf(x, y)); } int main() {int x, y; int input = 1; int ret = 0; int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表 do {menu(); //菜单 scanf("%d", &input); switch (input) {case 1: Calc(add); break; case 2: Calc(sub); break; case 3:Calc(mul); break; case 4:Calc(div); break; case 0: printf("退出\n"); break; default: printf("输出有误，请重新输入\n"); break; } } while (input); return 0; }

int* arr[3]; //整型指针数组 int*(*parr)[3]=&arr; //整型指针数组的地址放入parr //parr就是指向整型指针数组的指针 //而我们只需要将整型指针换成函数指针就ok了 int(*pf)(int,int); //函数指针 int(*pfarr[3])(int,int); //函数指针数组 int(*(*ppfarr)[3])(int,int)=&pfarr; //&pfarr //ppfarr是指针，指针指向一个数组，数组的类型为函数指针 //元素个数为3,函数的返回值为int,参数为int

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

Performs a quick sort.

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );

void

void *base
待排序的内容的首地址
size_t num
待排序元素的个数
size_t width
待排序元素的大小
int (__cdecl *compare )(const void *elem1, const void *elem2 )
自己定义一个排序的方式，例如一个结构体数组，结构体元素，按照结构体里的什么类型的数据的类型排序，所以需要自己定义一个campare排序方式！
然后将函数指针传参到qsot中！

//qsort函数使用实例 #include struct peo {char name[10]; char numb[12]; }; //自己定义一个排序的方式 int compare_char(const void* e1, const void* e2) { return strcmp(((struct peo*)e1)->numb, ((struct peo*)e2)->numb); //按照peo中numb排序 }int main() { //创建一个结构体数组 struct peo peo1[3] = { { "张三","15779770910"},{ "李四","17370126640"},{ "王五","12669781134"} }; int sz = sizeof(peo1) / sizeof(peo1[1]); qsort(peo1, sz, sizeof(peo1[1]), compare_char); for (int i = 0; i < sz; i++) {printf("%s\t%s\n",peo1[i].name,peo1[i].numb); } return 0; }

//模拟实现qsort //模仿qsort的功能实现一个通用的冒泡排序//void qsort(void* base, size_t num, size_t width, //int(__cdecl* compare)(const void* elem1, const void* elem2)); #include typedef struct student { char name[5]; int score; }Student; int compare_score(const void*e1,const void* e2) { return ((Student*)e1)->score - ((Student*)e2)->score; } int compare_name(const void* e1, const void* e2) { return strcmp(((Student*)e1)->name, ((Student*)e2)->name); } void swap(void* e1, void* e2, size_t width) { //将元素一个一个字节交换 int i = 0; for (i = 0; i < width; i++) {char tmp; tmp = *((char*)e1+i); *((char*)e1+i) = *((char*)e2+i); *((char*)e2+i) = tmp; } } void my_qsort(void* base, size_t num, size_t width, int(*compare)(const void* e1, const void* e2)) { int i = 0, j = 0,flag = 1; //趟数 for (i = 0; i < num-1; i++) {//每趟比较次数 for (j = 0; j < num - i - 1; j++) {//比较 //因为我们无法得知实参的类型，无法得知指针加减的步长 //所以我们强制转换成char*类型指针，通过width元素大小进行访问 if (compare((char*)base + width * j, (char*)base + (j + 1) * width)>0) {//交换 swap((char*)base + j * width, (char*)base + (j + 1) * width, width); flag = 0; }} if (flag == 1) break; } } int main() { Student student[5] = { { "李四",65},{ "张三",78},{ "王五",56},{ "老王",100},{ "小李",98} }; my_qsort(student, sizeof(student) / sizeof(student[1]),sizeof(student[0]),compare_score); int i = 0; for (i = 0; i < 5; i++) {printf("%s %d\n", student[i].name, student[i].score); } return 0; }

//一维数组 int a[] = { 1,2,3,4}; printf("%d\n",sizeof(a)); printf("%d\n",sizeof(a+0)); printf("%d\n",sizeof(*a)); printf("%d\n",sizeof(a+1)); printf("%d\n",sizeof(a[1])); printf("%d\n",sizeof(&a)); printf("%d\n",sizeof(*&a)); printf("%d\n",sizeof(&a+1)); printf("%d\n",sizeof(&a[0])); printf("%d\n",sizeof(&a[0]+1));

//一维数组 int a[] = { 1,2,3,4}; printf("%d\n",sizeof(a)); // 16 //sizeof数组名就是计算整个数组空间大小 printf("%d\n",sizeof(a+0)); // 4/8 //a+0说明数组名a表示首元素地址，加0后还是首元素地址， //地址就是指针，而指针大小统一为4/8 printf("%d\n",sizeof(*a)); //4 //解引用数组名，该处的数组名表示首元素地址， //*后就是第一个元素 int型所以为4 printf("%d\n",sizeof(a+1)); // 4/8 //解析同a+0，a+1代表第二个元素的地址，指针大小4/8 printf("%d\n",sizeof(a[1])); // 4 //a[1]为int 故为4 printf("%d\n",sizeof(&a)); // 4/8 //&数组名，得到了整个数组的地址，而指针大小4/8 printf("%d\n",sizeof(*&a)); // 16 //&a得到整个数组地址，而*&a得到整个数组 16 printf("%d\n",sizeof(&a+1)); // 4/8 //&数组名，得到整个数组的地址，&a+1还是数组地址， //而指针大小4/8 printf("%d\n",sizeof(&a[0])); // 4/8 //&a[0]得到第一个元素的地址，指针4/8 printf("%d\n",sizeof(&a[0]+1)); // 4/8 //&a[0]得到第一个元素的地址， //&a[0]+1第二个元素地址,而指针大小4/8

//字符数组 char arr[] = { 'a','b','c','d','e','f'}; printf("%d\n", sizeof(arr)); printf("%d\n", sizeof(arr+0)); printf("%d\n", sizeof(*arr)); printf("%d\n", sizeof(arr[1])); printf("%d\n", sizeof(&arr)); printf("%d\n", sizeof(&arr+1)); printf("%d\n", sizeof(&arr[0]+1)); printf("%d\n", strlen(arr)); printf("%d\n", strlen(arr+0)); printf("%d\n", strlen(*arr)); printf("%d\n", strlen(arr[1])); printf("%d\n", strlen(&arr)); printf("%d\n", strlen(&arr+1)); printf("%d\n", strlen(&arr[0]+1)); char arr[] = "abcdef"; printf("%d\n", sizeof(arr)); printf("%d\n", sizeof(arr+0)); printf("%d\n", sizeof(*arr)); printf("%d\n", sizeof(arr[1])); printf("%d\n", sizeof(&arr)); printf("%d\n", sizeof(&arr+1)); printf("%d\n", sizeof(&arr[0]+1)); printf("%d\n", strlen(arr)); printf("%d\n", strlen(arr+0)); printf("%d\n", strlen(*arr)); printf("%d\n", strlen(arr[1])); printf("%d\n", strlen(&arr)); printf("%d\n", strlen(&arr+1)); printf("%d\n", strlen(&arr[0]+1)); char *p = "abcdef"; printf("%d\n", sizeof(p)); printf("%d\n", sizeof(p+1)); printf("%d\n", sizeof(*p)); printf("%d\n", sizeof(p[0])); printf("%d\n", sizeof(&p)); printf("%d\n", sizeof(&p+1)); printf("%d\n", sizeof(&p[0]+1)); printf("%d\n", strlen(p)); printf("%d\n", strlen(p+1)); printf("%d\n", strlen(*p)); printf("%d\n", strlen(p[0])); printf("%d\n", strlen(&p)); printf("%d\n", strlen(&p+1)); printf("%d\n", strlen(&p[0]+1));

//字符数组 char arr[] = { 'a','b','c','d','e','f'}; printf("%d\n", sizeof(arr)); // 6 //sizeof数组名,就是整个数组 数组大小为6 printf("%d\n", sizeof(arr+0)); // 4/8 //arr+0，数组名就是首元素地址，arr+0也是首元素地址 //指针大小4/8 printf("%d\n", sizeof(*arr)); // 1 //解引用数组名，此时的数组名代表首元素地址， //解引用后得到第一个元素，元素大小1 printf("%d\n", sizeof(arr[1])); // 1 //arr[1]表示第一个元素，元素大小1 printf("%d\n", sizeof(&arr)); // 4/8 //&数组名，代表数组地址，指针大小4/8 printf("%d\n", sizeof(&arr+1)); //&arr 数组地址，&arr+1也是数组地址 //而指针变量大小4/8 printf("%d\n", sizeof(&arr[0]+1)); // 4/8 //&arr[0]第一个元素地址，&arr[0]+1第二个元素地址 printf("%d\n", strlen(arr)); //随机值 //stlen函数遇到'\0'停止计数 printf("%d\n", strlen(arr+0)); // 随机值 //同上 printf("%d\n", strlen(*arr)); // 报错 // stlen函数参数接收的是指针,*arr是第一个元素 printf("%d\n", strlen(arr[1])); //报错 //同上 printf("%d\n", strlen(&arr)); // 随机值 //&arr数组的地址，遇到'\0'停止计数 printf("%d\n", strlen(&arr+1)); // 随机值—6 //&arr+1 整个数组的地址加一跳过，数组大小 //而数组大小为6个字节，所以长度为随机值-6 printf("%d\n", strlen(&arr[0]+1)); //随机值-1 //&arr[0]+1得到数组第二个元素地址，从第一个元素计数 //计数结果为随机值，故从第二个为随机值-1

char arr[] = "abcdef"; //字符串数组，数组大小要加上'\0' printf("%d\n", sizeof(arr)); // 7 //sizeof arr arr表示整个数组 printf("%d\n", sizeof(arr+0)); // 4/8 //首元素地址加0还是首元素地址,指针大小为4/8 printf("%d\n", sizeof(*arr)); // 1 //*arr得到第一个元素,元素大小为 1bit printf("%d\n", sizeof(arr[1])); // 1 //同上 printf("%d\n", sizeof(&arr)); // 4/8 //&arr整个数组的地址，指针大小4/8 printf("%d\n", sizeof(&arr+1)); // 4/8 //&arr+1数组指针，指针大小4/8 printf("%d\n", sizeof(&arr[0]+1)); // 4/8 //&arr[0]第一个元素地址，&arr[0]+1第二个元素地址 //而指针大小4/8 printf("%d\n", strlen(arr)); // 6 //arr数组存到是字符串，字符串中含有'\0' printf("%d\n", strlen(arr+0)); // 6 // 同上 printf("%d\n", strlen(*arr)); // 报错 //*arr得到首元素，而strlen函数参数为指针类型 printf("%d\n", strlen(arr[1])); // 报错 //同上 printf("%d\n", strlen(&arr)); // 6 // &arr得到整个数组地址 printf("%d\n", strlen(&arr+1)); // 随机值 //&arr+1跳过整个数组 printf("%d\n", strlen(&arr[0]+1)); // 5 //&arr[0]+1得到第二个元素地址

char *p = "abcdef"; //const修饰的字符常量 printf("%d\n", sizeof(p)); // 4/8 //p是字符指针，指针大小4/8 printf("%d\n", sizeof(p+1)); // 4/8 //p+1字符指针，指针大小4/8 printf("%d\n", sizeof(*p)); // 1 //*p得到第一个元素，元素类型为char printf("%d\n", sizeof(p[0])); // 1 //同上 printf("%d\n", sizeof(&p)); // 4/8 //&p为字符指针，指针大小4/8 printf("%d\n", sizeof(&p+1)); //4/8 //&p+1为第二个字符地址，字符指针，指针大小4/8 printf("%d\n", sizeof(&p[0]+1)); // 4/8 //同上 printf("%d\n", strlen(p)); // 随机值 //p指针，所指空间，'\0'位置未知 printf("%d\n", strlen(p+1)); // 随机值-1 //p+1第二个字符地址 printf("%d\n", strlen(*p)); // 报错 // *p是字符，strlen参数为指针类型 printf("%d\n", strlen(p[0])); // 报错 //同上 printf("%d\n", strlen(&p)); // 另一随机值 // &p是二级指针， printf("%d\n", strlen(&p+1)); // 又另一随机值 //&p二级指针 ，&p+1后还是二级指针 printf("%d\n", strlen(&p[0]+1)); // 随机值—1 //&p[0]+1第二个字符地址

//二维数组 int a[3][4] = { 0 }; printf("%d\n", sizeof(a)); //48 //sizeof数组名.为整个数组 printf("%d\n", sizeof(a[0][0])); //4 //a[0][0]为第一元素 printf("%d\n", sizeof(a[0])); //16 //a[0]得到二维数组第一行 一行有4个元素 printf("%d\n", sizeof(a[0] + 1)); //4/8 //a[0]第一行地址，a[0]+1第二行地址 //第二行地址，数组地址，指针大小4/8 printf("%d\n", sizeof(*(a[0] + 1))); //4 //a[0]首元素地址，即第一行第一个元素地址， //加一得到第二个元素地址，解引用得到第二个元素 printf("%d\n", sizeof(a + 1)); //4/8 //a为第一行地址，a+1第二行地址 printf("%d\n", sizeof(*(a + 1))); //16 //a+1第二行地址,解引用后得到第二行 printf("%d\n", sizeof(&a[0] + 1)); //4/8 //&a[0]+1第二行地址 printf("%d\n", sizeof(*(&a[0] + 1))); //16 //&a[0]+1第二行地址 解引用得到第二行 printf("%d\n", sizeof(*a)); //16 //a第一行地址，解引用后得到第一行 printf("%d\n", sizeof(a[3])); //16 //数组越界，无第四行,但是根据二维数组前面行的大小 //sizeof认为a[3]相同大小

笔试题1

int main() {int a[5] = { 1, 2, 3, 4, 5 }; int *ptr = (int *)(&a + 1); printf( "%d,%d", *(a + 1), *(ptr - 1)); return 0; } //程序的结果是什么？

int main() {int a[5] = { 1, 2, 3, 4, 5 }; int* ptr = (int*)(&a + 1); //&a+1得到数组指针加一，指向数组末尾 //将数组指针强制类型转换成int*存放在ptr中 printf("%d,%d", *(a + 1), *(ptr - 1)); // 2,5 //a+1 a首元素地址，加一后得到第二个元素地址 // *(a + 1)解引用后得到 2 //ptr指针类型为int* ptr指向数组末尾 //ptr-1得到数组最后一个元素地址 // *(ptr - 1) 解引用得到最后一个元素5 return 0; }

笔试题2

//这里已知结构体的大小是20个字节 struct Test {int Num; char *pcName; short sDate; char cha[2]; short sBa[4]; }*p; //假设p 的值为0x100000。 如下表表达式的值分别为多少？ int main() {printf("%p\n", p + 0x1); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }

//这里已知结构体的大小是20个字节 struct Test {int Num; char* pcName; short sDate; char cha[2]; short sBa[4]; }*p; //假设p 的值为0x100000。 如下表表达式的值分别为多少？ int main() {p = (struct Test*)0x100000; printf("%#08x\n", p + 0x1); //0x00100020 //p是结构体指针类型，p+1跳过一个结构体大小 //结构体大小为20字节，所以跳过20 //0x100000+20 = 0x00100020 printf("%#08x\n", (unsigned long)p + 0x1); //0x100001 //(unsigned long)p 将0x100000强制类型转换 //转换成unsigned long 后 + 0x1就是直接加 //0x100000 + 0x1 = 0x100001 printf("%#08x\n", (unsigned int*)p + 0x1); //0x100004 //(unsigned int*)p 转换成 (unsigned int*)p // 加 1跳过一个unsigned int类型大小 4 //0x100000 + 4 =0x100004 return 0; }

笔试题3

int main() {int a[4] = { 1, 2, 3, 4 }; int *ptr1 = (int *)(&a + 1); int *ptr2 = (int *)((int)a + 1); printf( "%x,%x", ptr1[-1], *ptr2); return 0; }

int main() {int a[4] = { 1, 2, 3, 4 }; int* ptr1 = (int*)(&a + 1); //&a得到数组地址，&a+1跳过一个数组 //(int*)(&a+1)将数组指针强制转换 int* ptr2 = (int*)((int)a + 1); //(int)a 将a数组首元素地址强制转换int //(int)a+1后，a的地址码 + 1 //(int*)(int)a+1 转换成int*指针 printf("%x,%x", ptr1[-1], *ptr2); //4 , 2000000 //ptr1-1减去int类型大小，向前移动一个int型 //ptr2 指向了整个数组的第二个字节，访问一个int型 return 0; }

笔试题4

#include int main() {int a[3][2] = { (0, 1), (2, 3), (4, 5) }; int *p; p = a[0]; printf( "%d", p[0]); return 0; }

int main() {int a[3][2] = { (0, 1), (2, 3), (4, 5) }; //逗号表达式，初始化为{1,3,5} int* p; p = a[0]; //将a[0]第一行地址存入int*类型的p中 //即类型进行了转换成了int* printf("%d", p[0]); // 1 //此时的 p 是第一行第一个元素的地址 //p[0]就是 1 return 0; }

笔试题5

int main() {int a[5][5]; int(*p)[4]; p = a; printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); return 0; }

int main() {int a[5][5]; int(*p)[4]; //p为int [4] 类型的数组指针 p = a; //a为首元素地址，第一行的地址 //a为 int [5]数组指针 //将 a 赋值给 p printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); // fffffffc -4 // &p[4][2] - &a[4][2] = -4 return 0; }

笔试题6

int main() {int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int *ptr1 = (int *)(&aa + 1); int *ptr2 = (int *)(*(aa + 1)); printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1)); return 0; }

int main() {int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int* ptr1 = (int*)(&aa + 1); //&aa+1 跳过一个数组大小，数组指针 // aa+1指向数组的末尾 //(int*)(&aa + 1)转换成int*指针 int* ptr2 = (int*)(*(aa + 1)); //aa+1首元素地址 + 1 指向第二个元素地址 // 而这里的首元素地址就是第一行地址 // 加一后指向第二行地址 //(int*)(*(aa + 1))转换成 int*指针 printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1)); //10，5 //ptr1-1数组末尾指针-1 ptr1是int*指针 // 所以减一得到 最后一个元素地址 // 解引用后得到元素 10 //ptr2-1第二行数组地址-1 // 因为prt2是int*指针类型-1 跳过一个int类型 //*(ptr2-1)得到第一行最后一个元素 5 return 0; }

笔试题7

#include int main() {char *a[] = { "work","at","alibaba"}; char**pa = a; pa++; printf("%s\n", *pa); return 0; }

int main() {char* a[] = { "work","at","alibaba" }; char** pa = a; pa++; //pa++ 后指向char* "at" printf("%s\n", *pa); // at return 0; }

笔试题8

int main() {char *c[] = { "ENTER","NEW","POINT","FIRST"}; char**cp[] = { c+3,c+2,c+1,c}; char***cpp = cp; printf("%s\n", **++cpp); printf("%s\n", *--*++cpp+3); printf("%s\n", *cpp[-2]+3); printf("%s\n", cpp[-1][-1]+1); return 0; }

int main() {char* c[] = { "ENTER","NEW","POINT","FIRST" }; char** cp[] = { c + 3,c + 2,c + 1,c }; char*** cpp = cp; printf("%s\n", **++cpp); //POINT printf("%s\n", *-- * ++cpp + 3); //ER printf("%s\n", *cpp[-2] + 3); //ST printf("%s\n", cpp[-1][-1] + 1); //EW return 0; }

推荐阅读

• 

  哪里有最新搞笑图片和视频素材,有没有什么好的原创工具？
• 

  多给家人吃的营养菜，健康美味，开胃健脾，营养价值非常高
• 

  方差分析的p值范围
• 

  八仙指的是谁 八仙指的是谁 有哪些人物
• 

  描写夏天的诗句
• 

  运动会加油稿最新 怎么写运动会加油稿
• 

  吉林省敦化市经济排名 敦化市好吗
• 

  家庭变故一般指什么
• 

  青岛暖气几月开始几月结束 青岛暖气开始结束的时间
• 

  藏红花最佳饮用时间
• 

  云上的
• 

  弗朗西斯全明星首发 约基奇几次全明星首发
• 

  直播带货传播学分析，网络带货直播的传播现象
• 

  明天695特点特征，附简介
• 

  茶叶蛋能一直泡着吗怎么泡 茶叶蛋能一直泡着吗
• 

  u盘系统没有鼠标怎么，u盘启动没有鼠标键盘
• 

  兔波氏杆菌病症状 寒冬养兔谨防波氏杆菌病
• 

  鄄城的名胜古迹
• 

  马铃薯表皮龟裂的原因及预防措施有哪些 马铃薯表皮龟裂的原因及预防措施
• 

  哪些相机用蔡司镜头 佳能用蔡司镜头

• EffectiveObjective-C2.0|EffectiveObjective-C2.0 笔记 - 第二部分
• 深入理解Go之generate
• 考研英语阅读终极解决方案——阅读理解如何巧拿高分
• 由浅入深理解AOP
• Android中的AES加密-下
• 逻辑回归的理解与python示例
• 【1057快报】深入机关，走下田间，交通普法，共创文明
• 【读书笔记】贝叶斯原理
• 【韩语学习】（韩语随堂笔记整理）
• 人性的弱点-笔记