本节重点

1. 字符指针
2. 数组指针
3. 指针数组
4. 数组传参和指针传参
5. 函数指针（难）
6. 函数指针数组（难）
7. 指向函数指针数组的指针
8. 回调函数（难）

前言

在C语言基础阶段，我们学习过指针相关的一些基础内容，比如说：

1. 指针是一个变量，用来存放地址，地址是唯一标识一块内存空间
2. 指针的大小是固定的4 / 8个字节（32位平台 / 64位平台）
3. 指针是由类型，指针的类型决定了指针的 + -整数的步长，指针解引用操作时候的权限
4. 指针的运算

1.字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

一般使用:

int main()
{    char ch = 'w';    char* pc = &ch;    printf("%c\n", *pc);    return 0;
}

或

int main()
{//这里p指向字符串常量hello world 的首字符地址,字符串常量存储在只读数据段中const char* p = "hello world.";     //const char* p 值不可更改,地址可换printf("%s\n", p);						//%s --- 打印字符串//printf("%s\n", str);为什么不能写成printf("%s\n", *str);       //因为 %s 格式化字符串时，它期望一个 char* 类型的参数，即一个指向字符数组首元素的指针。这个指针指向的是字符串的开始位置。return 0;
}

扩展：在C语言中，内存可以被划分为栈区、堆区、静态区、常量区。

• 栈区：局部变量，函数形参，函数调用
• 堆区：动态内存如malloc等申请使用
• 静态区：全局变量，static修饰的局部变量
• 常量区：常量字符串(常量区中的内容在整个程序的执行期间是不允许被修改的，且同一份常量字符串只会创建一份，不会重复创建存储。)

有这样的面试题：

int main()
{char str1[] = "hello world";char str2[] = "hello world";const char* str3 = "hello world";const char* str4 = "hello world";if (str1 == str2)printf("str1 and str2 are same\n");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;
}
//!!!注 : 在C语言中，使用 == 操作符比较两个数组（或字符串）时，实际上是比较它们(内容)的地址，而不是它们的内容。

打印出的结果：

str1 and str2 are not same
str3 and str4 are same

![外链图片转存失败,源

(自我理解)

• str1与str2相当于先选两个位置(地址),再搭房子(存hello world),因此两房子不同(只是长得一样,不是同一个房子)
• 而str3与str4则相当于先造一个房子(存hello world),然后用两张纸写的同一个地址

2.指针数组

//整形数组，存放整形的数组int arr1[10];//字符数组，存放字符的数组char arr2[10];//指针数组,存放指针的数组//存放整形指针的数组int* arr3[5];//存放字符指针的数组char* arr4[10];

int main()
{const char* a[5] = {"abcdef", "zhangsan", "hehe", "wangcai", "ruhua"};//存放指针的数组 - 指针数组，//a[5]数组里面存放的是每个字符串首字符的地址int i = 0;for (i = 0; i < 5; i++){printf("%s\n", a[i]);		//依次打印}---int arr1[5] = { 1,2,3,4,5 };int arr2[5] = { 2,3,4,5,6 };int arr3[5] = { 3,4,5,6,7 };int* arr[3] = {arr1, arr2, arr3};//arr也是一个指针数组，利用指针数组实现二维数组int i = 0;int j = 0;for (i = 0; i < 3; i++){for (j = 0; j < 5; j++){printf("%d ", arr[i][j]);	// arr[i][j] 《==》 *(arr[i] + j) }printf("\n");}return ;
}

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

char* ch[5]; //字符指针的数组

char* arr2[4]; // 一级字符指针的数组

char** arr3[5]; //二级字符指针的数组(存放二级指针)

3.数组指针

3.1 数组指针的定义

int main()
{int a = 10;int* p1 = &a;//整型指针 - 指向整型的指针  - 存放整型变量的地址char ch = 'w';char* p2 = &ch;//字符指针 - 指向字符的指针  - 存放字符变量的地址int arr[10] = {1,2,3,4,5};int *pa[10] = &arr;//err，因为pa会先和[10]结合int (* pa)[10] = &arr;//注: [10]要保持一致//取出的是数组的地址存放到pa中，pa是数组指针变量//int(* )[10] -> 数组指针类型//数组指针 - 指向数组的指针  - 存放的是数组的地址return 0;
}

首先，我们要知道[]的优先级是比 * 要高的，对于形式1，pa会先与[ ]结合，再与 * 结合，所以形式1是指针数组

（）的优先级又比[]高，所以pa会先于 * 结合，在与[ ]结合，所以形式2是数组指针。

3.2 &数组名VS数组名

int main()
{int arr[10] = {0};printf("%p\n", arr);printf("%p\n", arr+1);printf("%p\n", &arr[0]);printf("%p\n", &arr[0]+1);printf("%p\n", &arr);printf("%p\n", &arr+1);return 0;
}

可以看出，arr+1 相较于 arr 跳过了4个字节的大小，

而 &arr+1 相较于 &arr 跳过了40（10*4）个字节，一个数组的地址

因为&arr 指向的是一整个数组

大多数情况下数组名是数组首元素的地址，但是有两个例外：

1. sizeof(数组名)
2. &数组名

3.3 数组指针的使用

3.3.1 对一维数组的使用

例: 1

int main()
{int arr[10]={1,2,3,4,5,6,7,8,9,10};int* p=arr ;int i =0;for(i=0;i<10;i++);{printf("%d",*(p+1));}return 0;
}

例: 2

int main()
{int arr[10]={1,2,3,4,5,6,7,8,9,10};int (*p)[10]=&arr;int i=10;for(i=0;i<10;i++){printf("%d",(*p)[i];}return 0;
}

可以看出对一维数组使用例1的方法更方便简捷,例2的方法有点鸡肋

3.3.2 对二维数组的使用

#include<stdio.h>
//常见的方式
void print_arr1(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");}
}//数组指针方式
void print_arr2(int(*p)[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 ", (*(p + i))[j]);printf("%d ", *(*p + i）+j);printf("%d ", *(p[i]+j);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} };  //对于二维数组,第一行为其第一个元素//打印这个二维数组print_arr1(arr,3,5);//数组名，行，列也要传参print_arr2(arr, 3, 5); //数组名-首元素地址return 0;
}

3.3.3 巩固练习

下面这些代码的含义是什么？

int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];

解析：

int arr[5];
//arr是一个数组，数组有5个元素，每个元素类型是int
//arr类型是  int [5]  --- 去掉变量名，剩下的就是变量的类型int* parr1[10];
//parr1是一个数组，数组有10个元素，每个元素类型是int*
//parr1是指针数组,类型是 int* [10]int(*parr2)[10];
//parr2是一个指针，指针指向一个数组，数组有10个元素，每个元素的类型是int
//parr2是数组指针,类型是 int(*)[10]int(*parr3[10])[5];
//parr3是一个数组，数组有10个元素，每个元素都是一个指 针
//指针指向一个数组，数组有5个元素，每个元素类型是int
//parr3是一个指向数组指针的数组，本质上还是数组
//parr3类型是 int(*[10])[5]

4.数组参数、指针参数

4.1 一维数组传参

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void test(int arr1[])//ok? 
{}
void test(int arr1[10]) //ok?
{}
void test(int* arr1)//ok?
{}
void test2(int* arr2[20])//ok?
{}
void test2(int** arr2) // ok ?     注:此处传进数组中储存的指针,//int* arr2则是存放指针的地址
{}
int main()
{int arr1[10] = { 0 };int* arr2[20] = { 0 };test(arr);test2(arr2);
}

答案：以上传参方式相对应的均ok

注意：一维数组传参可以传数组形式，也可以传指针形式，传数组形式的时候数组元素的个数可以不写，也可以写，传指针的时候要注意指针的类型，也就是指针指向什么类型的元素，

比如说指针指向int类型元素，那么指针的类型就是 int*

4.2 二维数组传参

void test(int arr[3][5])//ok ?
{}
//可以
void test(int arr[][])//ok ?
{}
//不可以，行可以省略，列不可以，第一个[ ]内容可以不写，第二个[ ]要写
void test(int arr[][5])//ok ?
{}
//可以
void test(int* arr)// ok ? 
{}
//不可以
void test(int* arr[5])//ok ?
{}
//不可以
void test(int(*arr)[5])//ok ?
{}
//可以
void test(int** arr)// ok ? 
{}
//不可以
int main()
{int arr[3][5] = { 0 };test(arr);
}

总结 : 二维数组传参，函数形参的设计只能省略第一个[ ]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
这样才方便运算。
二维数组传参也能写成指针的形式，指针的类型应该是数组指针。
传什么,就用什么接收

4.3 一级指针传参

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 print(int arr1[], int sz)
{int i = 0;for (i = 0; i < sz; i++){printf("%d\n", arr[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;
}

注:数组类型参数 arr 1发生退化，变成了指向数组第一个元素的指针。这意味着在函数内部，arr 1被当作一个指针来处理，而不是一个完整的数组。

4.4 二级指针传参

void test(int** p)
{
}
int main()
{int* p1;int** ptr;int* arr[5];test(&p1);//一级指针取地址.*p指向的元素test(ptr);//二级指针test2(arr);//一级指针数组的首元素(首地址)指向的元素return 0;
}

5.函数指针

我们创建函数的时候，就会在内存中开辟一块空间，既然占用了内存空间，那就有对应的内存空间地址。
函数指针，顾名思义就是指向函数的指针。

int add(int x,int y)
{return x + y;
}int main()
{printf("%p\n", add);printf("%p\n", &add);//注意：& 函数名 和 函数名均表示函数的地址！// 数组名 不等于 &数组名 但  函数名 等于 &函数名//注意这里，add 和 &add 是一样的，都是取函数的地址 //1.pf = &add;//2.(*pf)() = &add;//说明* pf是个函数,函数指向add//3.int (*pf)(int x, int y) = add;//函数的参数是（int x,int y），返回类型是intint (*pf)(int x, int y) = add;int sum = (*pf)(3, 5);			//函数指针的使用//pf就是函数指针变量printf("%d\n", sum);//int sum = add(3, 5);//int sum = pf(3, 5);像上面函数这样写也是ok的，//语法上来说，*可以去掉，我们加上*用来帮助理解(类似&add调用时不写&)return 0;
}

可以看出,函数指针和数组指针十分类似
int (*p)[10]
int (*p)(int ,int)

分下下面两段代码

代码1：

(*(void (*)())0)();
void (*)()——函数指针类型

(void (*)())0 —— 把0强制转化为一个函数的地址

(*(void ( * )())0)();——解引用0地址的函数，并调用

代码2：

void (*signal(int , void(*)(int)))(int);
signal ( int , void ( * )( int ) )——signal是函数名，
第一个参数是int，第二个参数是一个函数指针

剩下void（ * ）（ int ）——说明signal的返回类型也是一个函数指针类型

上述代码是一次函数声明
// 声明的函数叫：signal
// signal函数的第一个参数是int类型的
// signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
// signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void

// void (*)(int) signal(int, void( * )(int)); //err

上述简化是错的，可以用 typedef 函数进行简化

typedef void （*pf_t）（int） ;//pf_t为 void ( * )(int) 函数指针类型

pf_t signal( int, pf_t);

6.函数指针数组

数组是一个存放相同类型数据的存储空间，我们已经学习了指针数组与函数指针，比如︰

int* arr[10];
数组的每个元素是int*
与
int (* pf)(int…)—函数指针

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢 ?
int ( * parr1[10] )(int… ); √
int* parr2[10] ( ); x
int (*)( ) parr3[10]; x

• parr1先和[结合，说明parr1是数组。
• 数组的内容是什么呢 ?
• 是int(*)()类型的函数指针。

例题：
写一个计算器
整数的加、减、乘、除

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
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("***************************\n");printf("***** 1.add    2. sub  ****\n");printf("***** 3.mul    4. div  ****\n");printf("***** 0.exit           ****\n");}
int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择:>");scanf("%d", &input);switch (input){case 1:printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Add(x, y);printf("%d\n", ret);break;case 2:	printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Sub(x, y);printf("%d\n", ret);break;case 3:printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Mul(x, y);printf("%d\n", ret);break;case 4:printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Div(x, y);printf("%d\n", ret);break;case 0:printf("退出计算器\n");break;default:printf("选择错误\n");break;}} while (input);
}

改进

//这里省略各种函数，可参考上述代码
//函数指针数组   - 转移表
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择:>");scanf("%d", &input);if (input == 0){printf("退出计算器\n");break;}if (input >= 1 && input <= 4){printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = pfArr[input](x, y);printf("%d\n", ret);}else{printf("选择错误\n");}	} while (input);
}

这种函数指针数组 我们经常称为 转移表

7.指向函数指针数组的指针

函数指针：
int ( *pf ) ( int , int );函数指针数组：
int ( *pfarr[ 10 ] ) ( int , int );指向函数指针数组的指针:
int ( *  (*ptr)[10]   ) ( int , int ) = &pfarr;

暂时能认识就行

8.回调函数

8.1 回调函数定义

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

switch (input){case 1:printf("请输入2个操作数:>");//每个case中语句执行重复度太高scanf("%d %d", &x, &y);ret = Add(x, y);printf("%d\n", ret);break;case 2:	printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Sub(x, y);printf("%d\n", ret);break;case 3:printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Mul(x, y);printf("%d\n", ret);break;case 4:printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = Div(x, y);printf("%d\n", ret);break;case 0:printf("退出计算器\n");break;default:printf("选择错误\n");break;}

每个case中语句执行重复度太高
改进

//这里省略各类计算函数，可参考上面的代码
void calc(int (*p)(int, int))
{int x = 0;int y = 0;int ret = 0;printf("请输入2个操作数:>");scanf("%d %d", &x, &y);ret = p(x, y);printf("%d\n", ret);
}
int main()
{int input = 0;do{menu();printf("请选择:>");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);

当calc函数传送的是Add函数的地址，这是p调用的是Add函数，这是我们称Add为回调函数

这里并不是直接调用各种计算函数，而是把计算函数函数的地址，传递给了calc函数
再由calc函数指针 int ( * p)(int, int) 之后，在适当位置通过函数指针 p 调用它所指向的函数

这个机制就称为回调函数

8.2 qsort函数的使用

8.2.1 回顾冒泡排序

void bubble_sort(int arr[],int sz)
{//趟数int i=0;for(i=0;i<sz-1:i++){//一趟排序的过程int j=0;for(j=0;j<sz-1-i;j++){if(arr[j]>arr[j+i]){int tem=arr[i];arr[j]=arr[j+i];arr[j+i]=tem;}}}
}int main(
{//对数组进行排序升序int arr[]={9,8,7,6,5,4,3,2,1,0};int sz=sizeof(arr)/sizeof(arr[0]);bubble_sort(arr,sz);//0,1,2,3,4,5,6,7,8,9//打印int i=0;for(i=0;i<sz;i++){printf("%d",arr[i]);}
}
//缺陷 : 只能排整数

8.2.2 qsort介绍

使用
void qsort(void* base,size_t num,size_t size,int (*cmpar)(const void*, const void*));
void qsort(void* base,//待排序目标数组的起始位置size_t num,//数组的元素个数size_t width,//每个元素占用的字节数int(__cdecl * compare)(const void* elem1, const void* elem2)//函数指针，排序所使用的比较函数//不同类型的数据比较的方法是不一样的，所以需要将比较方法写成函数传递给qsort//简化：int(* cmp)(const void* elem1, const void* elem2) //函数指针，指针指向的参数有两个，参数类型都是const void*,函数返回类型是intint arr[]={9,8,7,6,5,4,3,2,1,0};
qsort(arr , sz , sizeof(arr[0]))

void* 类型讲解： void是无，空的含义，void * 表示的是无类型的指针。 void* 指针可以接收任意类型的地址（void 可以看作指针万能筒，可以接收任意类型） void 类型指针不能进行解引用操作的。

理解：我们知道指针的类型决定了指针解引用操作时访问字节的个数，如果指针类型是void * ，无类型指针，那么就无法得知该指针解引用访问多少个字节数。
void* 类型指针不能进行++ / ±整数运算的操作。

理解：我们知道指针类型的意义除了决定指针解引用时访问字节的个数外，还决定了指针 + -整数运算的步长，如果指针类型是void *
无类型指针，那么就无法得知该指针 + -的步长到底是多少个字节。

8.2.3 qsort在升序降序中的使用

#include<stdio.h>
#include<stdlib.h>//为了调用qsort，需要将比较函数传给qsort//按照qsort函数参数的类型，写出需要使用的比较函数int cmp_int(const void* elem1, const void* elem2)
{return *(int*)elem1 - *(int*)elem2;
}
void test1()
{int arr[] = { 9,8,7,6,5,4,3,2,1,0 };int sz = sizeof(arr) / sizeof(arr[0]);int i = 0;qsort(arr, sz, sizeof(arr[0]), cmp_int);for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}
int main()
{test1();//排序整型数组并打印return 0;
}

8.2.3 qsort在结构体排序中的使用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{char name[20];int age;
};
int cmp_Stu_by_age(const void* e1, const void* e2)
{return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_Stu_by_name(const void* e1, const void* e2)
{//字符串比较需要用到字符串比较库函数strcmpreturn strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test3()
{struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };int sz = sizeof(s) / sizeof(s[0]);int i = 0;qsort(s, sz, sizeof(s[0]), cmp_Stu_by_age);printf("按年龄排序：\n");for (i = 0; i < sz; i++){printf("%s,%d\n", s[i].name, s[i].age);}qsort(s, sz, sizeof(s[0]), cmp_Stu_by_name);printf("按名字排序：\n");for (i = 0; i < sz; i++){printf("%s,%d\n", s[i].name, s[i].age);}
}
int main()
{test3();//排序结构体数组并打印return 0;
}

8.3 用冒泡函数的思想实现 qsort 函数

改造冒泡排序,使得其能排序任意指定数组

#include<stdio.h>
#include<string.h>
int cmp_int(const void* elem1, const void* elem2)
{return (*(int*)elem1 - *(int*)elem2);
}
void Swap(char* e1, char* e2, int width)
{int i = 0;//逐个字节交换for (i = 0; i < width; i++){//方法一：//char tmp = *(e1 + i);//*(e1 + i) = *(e2 + i);//*(e2 + i) = tmp;//方法二：char tmp = *e1;*e1 = *e2;*e2 = tmp;e1++;e2++;}
}void Bubble_sort(void* base, int num, int width, int (*cmp)(void* e1, void* e2))
{int i = 0;//size_t就是unsigned int无符号整型的类型重定义，这里可以直接用int类型//确定排序的趟数for (i = 0; i < num - 1; i++){int j = 0;//确定每趟排序的对数for (j = 0; j < num - 1 - i; j++){//比较大小if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){//元素位置交换Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}//void qsort(void* base,//待排序目标数组的起始位置
//	       size_t num,//数组的元素个数
//	       size_t width,//每个元素占用的字节数
//	       int(__cdecl* compare)(const void* elem1, const void* elem2)//函数指针，
//排序所使用的比较函数
//   //简化：int(* cmp)(const void* elem1, const void* elem2) 
//   //函数指针，指针指向的参数有两个，参数类型都是const void*,函数返回类型是int
//   //不同类型的数据比较的方法是不一样的，所以需要将比较方法写成函数传递给qsort
//           );void test4()
{int arr[] = { 1,3,5,7,9,2,4,6,8,10 };int sz = sizeof(arr) / sizeof(arr[0]);int i = 0;Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}struct Stu
{char name[20];int age;
};
int cmp_Stu_by_age(const void* e1, const void* e2)
{return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_Stu_by_name(const void* e1, const void* e2)
{//字符串比较需要用到字符串比较库函数strcmpreturn strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}void test3()
{struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };int sz = sizeof(s) / sizeof(s[0]);int i = 0;qsort(s, sz, sizeof(s[0]), cmp_Stu_by_age);printf("按年龄排序：\n");for (i = 0; i < sz; i++){printf("%s,%d\n", s[i].name, s[i].age);}Bubble_sort(s, sz, sizeof(s[0]), cmp_Stu_by_name);printf("按名字排序：\n");for (i = 0; i < sz; i++){printf("%s,%d\n", s[i].name, s[i].age);}
}
int main()
{test3();//调用模拟排序函数排序struct Stu类型数据并打印test4();//调用模拟排序函数排序int类型数据并打印return 0;
}

9.指针和数组经典笔试题解析

9.1 arr[],{ 1,2,3,4 },sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{//一维数组int a[] = { 1,2,3,4 };printf("%d\n", (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));return 0;
}

解析：数组名表示首元素地址，但有两个例外：
1.sizeof(数组名)-- - 此时数组名表示整个数组。
2.& 数组名-- - 此时数组名表示整个数组。
注意：上面这两种例外的情况都需要 sizeof / &后面直接跟数组名，如果不是直接 + 数组名，则不是表示整数数组。
除了上面两个例外情况外，余下遇到的所有情况数组名均表示首元素地址

#include<stdio.h>
int main()
{//一维数组int a[] = { 1,2,3,4 };printf("%d\n", sizeof(a));// 16 sizeof(数组名)，数组名表示整个数组，大小为4*4=16个字节printf("%d\n", sizeof(a + 0));//4/8 此时数组名表示首元素地址，a+0首元素地址+0仍表示首元素地址，地址大小为4/8个字节printf("%d\n", sizeof(*a));// 4  此时数组名表示首元素地址,*a表示首元素，为int类型，大小为4个字节printf("%d\n", sizeof(a + 1));//4/8 此时数组名表示首元素地址，a+1 首元素地址+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是对数组地址解引用，得到是数组，sizeof(数组)计算数组大小--16printf("%d\n", sizeof(&a + 1));//4/8 &a是取出数组地址,&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个字节return 0;
}

9.2 arr[],{‘a’,‘b’,‘c’},sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{//字符数组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));return 0;
}

详解及结果展示：

#include<stdio.h>
int main()
{//字符数组char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };printf("%d \n", sizeof(arr));//6  计算的是数组大小，每个元素是一个字符，6*1=1printf("%d\n", sizeof(arr + 0));//4/8 arr+0还是表示首元素地址，地址大小是4/8个字节printf("%d\n", sizeof(*arr));//1 *arr表示首元素，类型是char，char大小是1个字节printf("%d\n", sizeof(arr[1]));//1 arr[1]表示第二个元素，类型是char，char大小是1个字节printf("%d\n", sizeof(&arr));//4/8 &arr表示取出数组的地址，地址大小是4/8个字节printf("%d\n", sizeof(&arr + 1));//4/8 &arr表示取出数组的地址,&arr+1表示跳过整个数组，到数组后面的地址，地址大小是4/8个字节 printf("%d \n", sizeof(&arr[0] + 1));//4/8 &arr[0]表示取出首元素的地址，&arr[0]+1表示取出第二个元素的地址，地址大小是4/8个字节return 0;
}

9.3 arr[],{‘a’,‘b’,‘c’},strlen

请写出下面程序执行的结果
strlen函数是求字符串长度，需要找到 ’/0 ’

#include<stdio.h>
#include<string.h>
int main()
{//字符数组char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };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));return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{//字符数组char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };printf("%d\n", strlen(arr));//随机值， arr表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值printf("%d\n", strlen(arr + 0));//随机值， arr+0表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值printf("%d\n", str1en(*arr));//错误写法 ,strlen后面需要传递一个地址，*arr表示首元素，首元素是字符'a',其ASCII码是97，strlen会将97当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", strlen(arr[1]));//错误写法 ,strlen后面需要传递一个地址，arr[1]表示第二个元素，首元素是字符'b',其ASCII码是98，strlen会将97当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", strlen(&arr));//随机值, &arr表示数组的地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值printf("%d\n", strlen(&arr + 1));//随机值， &arr+1表示跳过数组后的地址，后面不知道什么时候遇到'\0',所以是随机值printf("%d\n", strlen(&arr[0] + 1));//随机值， &arr[0] + 1表示第二个元素的地址，后面不知道什么时候遇到'\0',所以是随机值return 0;
}

9.4 arr[],“abcdef”,sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{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));return 0;
}

sizeof只关注占用内存空间的大小,单位是字节,不关心内存中存放的是什么
sizeof是操作符
strlen是求字符串长度的,统计的是\0出现前出现的字符个数,找到\0结束,所以可能存在越界访问
strlen是库函数
详解及结果展示：

#include<stdio.h>
int main()
{char arr[] = "abcdef";printf("%d\n", sizeof(arr));//7  用字符串来初始化字符串数组时，最后会自动添加字符串结束标志'\0'//数组arr中实际存放 abcdef+\0 7个元素 所以sizeof(arr)求数组的长度是 1*7=7个字节printf("%d\n", sizeof(arr + 0));//4/8   arr + 0表示首元素地址，地址的大小是4/8个字节printf("%d\n", sizeof(*arr));//1  *arr表示首元素，arr首元素是一个字符char类型'a',大小是1个字节printf("%d\n", sizeof(arr[1]));//1  arr[1]表示第二个元素，arr首元素是一个字符char类型'a',大小是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个字节return 0;
}

9.5 arr[],“abcdef”,strlen

请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{char arr[] = "abcdef";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));return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{char arr[] = "abcdef";printf("%d\n", strlen(arr));//6 数组arr中实际包含"abcdef \0"，strlen在往后找\0的时候，经过6个char刚好找到\0//strlen在计算字符串长度的时候，'\0'不计算到长度中printf("%d\n", strlen(arr + 0));//6 arr + 0表示首元素地址，与'\0'差6个字符，所以strlen计算长度为6printf("%d\n", strlen(*arr)); //错误写法 *arr表示首元素，为字符‘a’，ASCII码是97，strlen会将97当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", str1en(arr[1])); //错误写法 arr[1]表示第二个元素，为字符‘b’，ASCII码是98，strlen会将98当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", strlen(&arr));//6 &arr取出数组的地址，strlen在接收地址的时候是char*,会将数组的地址当作char*来使用//往后寻找'\0',经过6个char刚好找到\0printf("%d\n", strlen(&arr + 1));//随机值 &arr + 1跳过数组得到数组后面的地址，什么时候会遇到'\0'不确定，所以是随机值printf("%d\n", strlen(&arr[0] + 1));//5  &arr[0] + 1表示第二个元素的地址，经过5个char遇到'\0'，所以strlen计算长度为5return 0;
}

9.6 *p,“abcdef”,sizeof

请写出下面程序执行的结果

#include<stdio.h>
int main()
{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));return 0;
}

详解及结果展示：

#include<stdio.h>
int main()
{char* p = "abcdef";//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,//即字符串"abcdef"中字符'a'的地址printf("%d \n", sizeof(p));//4/8 p是一个指针，指针大小32位/64位平台为4/8printf("%d\n", sizeof(p + 1));//4/8 p+1是一个地址，字符'b'的地址，地址大小为4/8printf("%d\n", sizeof(*p));//1  *p表示字符'a',类型是char，大小为1个字节printf("%d\n", sizeof(p[0]));//1  p[0]( 即: *(p+0) )常量字符串第一个元素，即'a',类型是char，大小为1个字节printf("%d\n", sizeof(&p));//4/8 &p表示取出p的地址，地址大小为4/8printf("%d\n", sizeof(&p + 1));//4/8 &p+1表示取出p后面的地址，地址大小为4/8printf("%d\n", sizeof(&p[0] + 1));//4/8 &p[0] + 1表示第二个元素的地址，即'b'的地址，地址大小为4/8return 0;
}

9.7 *p,“abcdef”,strlen

请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{char* p = "abcdef";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));return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{char* p = "abcdef";//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,//即字符串"abcdef"中字符'a'的地址printf("%d\n", strlen(p));//6 p存储的是'a'的地址，strlen从a开始往后找6个字符，找到'\0'//所以strlen计算的字符串长度为6printf("%d\n", strlen(p + 1));//5 p + 1是'b'的地址,strlen从b开始往后找5个字符，找到'\0'printf("%d \n", strlen(*p));//错误写法 *p为字符‘a’，ASCII码是97，strlen会将97当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", strlen(p[0]));//错误写法 p[0]为字符‘a’，ASCII码是97，strlen会将97当作地址来处理//此时会造成越界访问，运行时会报错printf("%d\n", strlen(&p));//随机值 取出p的地址，传给strlen，strlen在往后寻找'\0',不知道什么时候遇到'\0'printf("%d\n", strlen(&p + 1));//随机值 取出p后面的地址，传给strlen，strlen在往后寻找'\0',不知道什么时候遇到'\0'printf("%d \n", strlen(&p[0] + 1));//5 p[0]表示首元素，&p[0]表示首元素地址，&p[0] + 1表示第二个元素'b'的地址//strlen从'b'开始计算字符串长度return 0;
}

9.8 arr[][],{0},sizeof

请写出下面程序执行的结果

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

知识储备：
二维数组的数组名表示首元素地址时，首元素指的是第一行数组，也就是说首元素是数组，数组名表示的是第一行数组的地址

详解及结果展示：

#include<stdio.h>
int main()
{//二维数组int a[3][4] = { 0 };printf("%d\n", sizeof(a));//3*4*4=48printf("%d\n", sizeof(a[0][0]));//4printf("%d \n", sizeof(a[0]));//4*4=16  a[0]相当于第一行作为一维数组的数组名，//sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小printf("%d\n", sizeof(a[0] + 1));//4/8   a[0]+1， a[0]放到表达式中了，是第一行作为数组的数组名，此时表示首元素地址//a[0]+1表示第一行第二个元素的地址，地址的大小为4/8printf("%d\n", sizeof(*(a[0] + 1)));//4    a[0]+1表示第一行第二个元素的地址 *(a[0] + 1)表示第一行第二个元素，类型是intprintf("%d\n", sizeof(a + 1));//4/8   a表示首元素地址，把二维数组看作一维数组，a即第一行数组的地址，a + 1表示第二行的地址，地址的大小为4/8printf("%d\n", sizeof(*(a + 1)));//4*4=16  a + 1表示第二行的地址,*(a + 1)表示第二行数组，数组有4个元素，均为int类型printf("%d\n", sizeof(&a[0] + 1));//4/8    a[0]放到表达式中了，是第一行作为数组的数组名，此时表示首元素地址//&a[0] + 1表示第二行数组的地址，地址的大小是4/8printf("%d\n", sizeof(*(&a[0] + 1)));//4*4=16   &a[0] + 1表示第二行数组的地址,*(&a[0] + 1)表示第二行数组，数组有4个元素，均为int类型printf("%d\n", sizeof(*a));//4*4=16   a表示二维数组首元素地址，即第一行数组的地址，*a表示第一行数组，大小为4*4printf("%d \n", sizeof(a[3]));//4*4=16   假设有第四行的数组，此时第四行数组的大小是4*4=16//sizeof操作符()内部不参与`真实运算`，所以实际上没有去越界访问return 0;
}

10.指针笔试题

笔试题1：

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

2，5

(int*)(&a+1)，这里&a表示数组的地址，然后+1是跳过整个数组大小，
*（a+1）表示首元素地址+1，就是a[2]的地址，然后解引用，就打印2
*(ptr - 1) 表示在跳过一个数组地址后再-1；就得到了没有跳过之前数组的最后一个元素的地址，再进行解引用，就得到了5

笔试题2：

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{int Num;char* pcName;short sDate;char cha[2];short sBa[4];
}* p;//p是一个结构体指针变量//X86环境下演示：
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{p = (struct Test*)0x100000;//这里是强制把0x100000地址赋值给pprintf("%p\n", p + 0x1);//这里就是给整个结构体地址+1，跳过一个结构体的地址20；0x100014printf("%p\n", (unsigned long)p + 0x1);//就是强制转换为整形+1；0x100001printf("%p\n", (unsigned int*)p + 0x1);//就是强制换行为地址+1，就是加4；0x100004return 0;
}

笔试题3：

//小端,X86环境
#include<stdio.h>
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;
}

#include<stdio.h>
int main()
{int a[4] = { 1,2,3,4 };int* ptr1 = (int*)(&a + 1);//&a表示取出数组的地址，&a+1表示跳过数组，到数组后面的地址//(int*)(&a+1)将这个地址强制类型转换成int*，放到ptr1里面int* ptr2 = (int*)((int)a + 1);//a表示数组首元素地址，（int）a将这个地址强制类型转换成int类型//(int)a + 1,就是地址+1//(int*)((int)a + 1)将这个地址强制类型转换成int*，放到ptr2里面printf("%x,%x", ptr1[-1], *ptr2);//4 ptr[-1]==>*(ptr-1)得到数组最后一个元素，即4，%x八进制打印结果也是4//02 00 00 00 *ptr2得到的就是被强制类型转换为int类型的地址的值+1，地址的单位是字节//ptr2解引用就是访问 00 00 00 02 （小端字节序存储），打印的时候就是 02 00 00 00return 0;
}

笔试题4：

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

#include<stdio.h>
int main()
{int a[3][2] = { (0,1),(2,3),(4,5) };//初始化{}内部的( )是逗号表示式，结果是最后一个表达式的结果//相当于{1,3,5}int* p;p = a[0];//a[0]是第一行数组名，没有&，没有单独放到sizeofn（）内，表示首元素地址//将二维数组第一行第一个元素的地址赋值给pprintf("%d", p[0]);//等价*(p+0)//1return 0;
}

笔试题5：

#include<stdio.h>
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;
}

笔试题6：

#include<stdio.h>
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;
}

详解及结果展示：

#include<stdio.h>
int main()
{int aa[2][5] = { 1,2,3,4,5,6,7,8,9,10 };int* ptr1 = (int*)(&aa + 1);//&aa + 1 跳过整个数组，指向数组后面的地址int* ptr2 = (int*)(*(aa + 1));//*(aa + 1) 等价与aa[1]，第二行首元素地址printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10,5return 0;
}

笔试题7：

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

#include<stdio.h>
int main()
{//字符指针数组只存储每个字符串-首字符地址char* a[] = { "work","at","alibaba" };char** pa = a;pa++;//pa指向a[1]的地址，a[1]存放"at"常量字符串的首地址printf("%s\n", *pa);//*pa找到a[1]，打印 atreturn 0;
}

笔试题8：

#include<stdio.h>
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;
}

#include<stdio.h>
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);//注:printf里面执行的语句一直存在且生效//先看（*++cpp）解引用拿到C+1内容，然后(*--c+1)，内容由（c+1）变成了（c）了，就由c的地址解引用指向"ENTER",最后+3移动3个字节，打印"ER"//"ER"printf("%s\n", *cpp[-2] + 3);//"ST"printf("%s\n", cpp[-1][-1] + 1);//"EW"return 0;
}