目录
一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。
因为传二维数组本质上传的是首元素地址，传过去的首元素地址就是第一行
qsort是库函数，基于快速排序算法实现的一个排序代码，qsort可以排序任意类型数据
1. 字符指针
char ch = 'w';
char* pc = &ch;//把字符变量ch地址放在字符指针变量中
*pc = 'a';//把pc指向的ch内容改变1.2 常量字符串(存放在常量区)
char *p = "abcdef";//p是指针变量，char*占4/8字节，实际上是把首字符a的首地址放到char*中
//abcdef在内存中连续存放，是一块连续的字符串，知道a就知道后面常量字符串内容不能被修改
char *p = "abcdef";
*p = 'w'; //错误
const char *p = "abcdef";//正确1.3 常量字符串面试题
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}答案：
这里str3和str4指向的是同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域（常量区），当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。
但是用相同的常量字符串去初始化 不同的数组的时候就会开辟出不同的内存块（栈区）。所以str1和str2不同，str3和str4不同。
2. 指针数组
指针数组
存放指针的数组
整型数组
int arr[10];//存放整型的数组
字符数组
char arr2[5];//存放字符的数组
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组int main()
{
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* parr[3] = { arr1, arr2, arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
//printf("%d ", parr[i][j]);
printf("%d ", *(parr[i]+j));
}
printf("\n");
}
return 0;
}
3.1 数组指针
数组指针是指针，指向数组的指针
int main()
{
int a = 10;
int *p = &a;//整型指针 - 指向整型的指针， 存放整型变量地址的
char ch = 'w';
char* pc= &ch;//字符指针 - 指向字符的指针，存放的是字符变量的地址
//数组指针 - 指向数组的指针
int* p1[10];//指针数组，p1和[]结合，p1是数组名，p1就是数组，十个元素，每个元素是int*
int(*p2)[10];//数组指针，数组名和*结合，是指针，向外一看10个元素数组，每个元素是int类型
return 0;
}[ ]的优先级高于*号，必须加上（）来保证p先和*结合
int main()
{
int arr[10] = {0};
int(*parr)[10] = &arr;//取出整个数组地址，*先和数组名结合，代表指针，10个元素，类型是int
//int(*)[10] 名字去掉，剩下的就是数组指针类型
printf("%p\n", &arr);//int(*)[10]
printf("%p\n", &arr+1);//地址+1，跳过一个int(*)[10]数组大小
return 0;
}
通常情况下，我们说的数组名都是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小
2. &数组名，这里的数组名表示整个数组，&数组名，取出的是整个数组的地址
3.2 写一个函数，打印arr二维数组
void print2(int(*p)[5], int c, int r)
{
int i = 0;
for (i = 0; i < c; i++)
{
int j = 0;
for (j = 0; j < r; j++)
{
//p+i是指向第i行的
//*(p+i)相当于拿到了第i行，也相当于第i行的数组名
//数组名表示首元素的地址，*(p+i) 就是第i行第一个元素的地址
printf("%d ", *(*(p + i) + j));
//printf("%d ", p[i][j]);
}
//arr[i]
//*(arr+i)
//
//arr[i][j]
//*(arr+i)[j]
//*(*(arr+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} };
//int (*ptr)[3][5] = &arr;
//写一个函数，打印arr数组
print2(arr, 3, 5);
return 0;
}3.3 下面代码的意思
int arr[5];//arr是一个整形数组，每个元素是int类型的，有5个元素
int *parr1[10];//指针数组，数组10个元素，每个元素的类型是int*
int (*parr2)[10];//parr2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是int
int (*parr3[10])[5];//parr3 是一个数组，数组有10个元素，每个元素的类型是：int(*)[5]
//把parr3[10]去掉，剩下元素的类型是：int(*)[5]，所以parr3是存放数组指针的数组
4. 数组传参和指针传参
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.2 一维数组传参
#include <stdio.h>
形参写成数组形式（本质传过去地址，数组名就是地址）
void test(int arr[])//正确，形参写成数组传参没问题，形参部分数组大小可以省略
{}//本质上是指针，写成数组形式，C语言会自动转换成指针形式
void test(int arr[10])//正确，数组传参时并没有创建形参，大小写多少都无所谓，无意义不提倡
{}
void test(int* arr)//正确，int类型地址放到int类型指针中
{}
形参写成指针形式（数组名表示首元素地址，类型int/int*）
void test2(int* arr[20])//正确，用数组形式接收，20同样可以省略
{}
void test2(int** arr)//正确，int*类型地址放到int**二级指针中
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
}4.3 二维数组传参
void test(int arr[3][5])//正确，按照数组方式写
{}
void test(int arr[][])//错误，行可以省略，列不能省略
{}//行写成多大多小无所谓，因为根本不会创建数组
void test(int arr[][5])//正确，行可以省略，列不能省略，传二维数组本质上传的是首元素地址
{}
void test(int *arr)//错误，首元素地址是第一行
{}
void test(int* arr[5])//错误，数组名表示首元素地址，地址放在数组里面错误
{}
void test(int (*arr)[5])//正确，用数组指针接收，指针指向五个元素，每个元素int类型
{}
void test(int **arr)//错误，二级指针是用来存放一级指针的地址，但是传过来的是数组（一行）地址
{}
int main()
{
int arr[3][5] = {0};
test(arr);传过去的是一个int[5]一维数组地址
}
void test1(int (*p)[5])
{}
void test2(int(*p)[3][5])
{
//*p;拿到的是二维数组数组名
}
int main()
{
int arr[3][5];
test1(arr);//传递的第一行的地址
test2(&arr);//传递的是整个二维数组的地址,类似一维数组，这样传很麻烦
return 0;
}
总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。
因为传二维数组本质上传的是首元素地址，传过去的首元素地址就是第一行
4.4 一级指针传参
void test(int* ptr)
{
//...
}
int main()
{
int a = 10;
int* p = &a;
int arr[10];
test(arr);//数组
test(&a);//p是一级指针
test(p);
return 0;
}
4.5 二级指针传参
void test(char** ppc)//二级指针传参，二级指针接收
{
}
int main()
{
char a = 'w';
char* pa = &a;
char** ppa = &pa;//ppa就是一个二级指针
test(ppa);
return 0;
}
当函数的参数为二级指针的时候，可以接收什么参数？
void test(char** ppc)
{
}
int main()
{
char ch = 'a';
char* pc = &ch;
char** ppc = &pc;
char* arr[4];
//char arr2[3][5];
//test(arr2);//错误
test(arr);正确
test(&pc);正确
test(ppc);正确
return 0;
}
5.1 函数指针 --指向函数的指针
想拿到函数的地址，这两种写法都可以，写法不同，意义一样
#include <stdio.h>
void test(void)
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
想把Add地址存起来，我们应该怎么存？
void(*pf)(void) =Add;//*与pf相结合代表是指针，void是函数返回类型，（void）是函数参数
//pf是函数指针变量，可以按照数组指针方式理解
return 0;
}
再来一个试试，已知函数类型，写出函数指针
int test(char* str)
{
}
int(*pf)(char*)= test;//*与pf结合，返回类型是int，函数参数是char*5.2 调用函数参数
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (* pf)(int, int) = Add;//就是函数指针变量
int ret = (*pf)(2,3); //函数指针使用，pf变量存放地址，解应用找到函数，再传参2,3
//等价于int ret = Add(2, 3);
//等价于int ret = pf(2, 3);pf还是能找到函数地址，说明这里的*是无意义
//等价于int ret = (*************pf)(2,3);多少*都没问题
printf("%d\n", ret);
return 0;
}
5.3 阅读两段有趣的代码
//代码1
(*(void (*)())0)();
解释：1.
首先是把0强制类型转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void，无参的一个函数
2. 调用0地址处的这个函数
//代码2
void (*signal(int , void(*)(int)))(int);解释：
1.signal这个代码本质上是一个函数的声明，类似
int Add(int,int);//有一个函数Add，参数int，int，返回类型int2.signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
3.signal函数的返回值类型也是：void(*)(int)的函数指针
当然也可以简化这个代码
typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
pf_t signal(int, pf_t);
6.1 函数指针数组
要把函数的地址存到一个数组中，那这个数组就叫函数指针数组
那函数指针的数组如何定义呢？
int (*parr1[10])();
//parr1先和[]结合代表数组，数组10个元素，去掉parr1[10],int(*)()就是一个函数指针6.2 用函数指针数组实现一个：计算器（转移表 ）
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");
printf("**************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
//转移表
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}优点：这样写减少代码冗余，比以前switch，case语句简化许多
也让让未来代码需要添加新的功能变得很方便
函数指针数组起到了跳板的作用，但是只有函数参数和返回类型一致才可以
7. 指向函数指针数组的指针
int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};//数组指针数组
int (*(* p3)[4])(int, int) = &pfarr;//p3是一个指向函数指针数组的指针
//*p3代表是指针，指向了数组，数组4个元素，每个元素类型是数组指针，返回值int，参数int，int
int main()
{
//函数指针数组
int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};
int (*(* p3)[4])(int, int) = &pfarr;//p3是一个指向函数指针数组的指针
int i = 0;
for (i = 0; i < 4; i++)
{
//*p
//*(p3+0)
//p3[0]
//int ret = (*p3)[i](3,4);//由于拿到的是整个数组的地址，*p3解应用才是数组首元素地址
int ret = p3[0][i](3, 4);
printf("%d\n", ret);
}
return 0;
}
你甚至可以进行俄罗斯套娃，无限套娃套下去
8.1 回调函数
概念:回调函数就是一个通过函数指针调用的函数。
如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。
回调函数例子（计算器版本）
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");
printf("**************************\n");
}
void calc(int (*pf)(int,int))//把函数地址传过来，在适当时通过函数指针调用函数
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pf(x, y);//通过pf调用谁，谁就被称为回调函数
printf("ret = %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);
return 0;
}
8.2 如何使用qsort完成快速排序
qsort是库函数，基于快速排序算法实现的一个排序代码，qsort可以排序任意类型数据
qsort要求传过来的四个数据类型
void qsort
(
void *base, //待排序数据的起始地址
size_t num, //待排序数据元素个数
size_t width, //一个元素的字节大小
int ( *cmp )(const void *el, const void *e2 ) );//是函数指针，其中cmp是比较函数
//e1和e2是需要代比较的两个元素的地址，因为排序一定要知道哪个大哪个小
//函数指针返回值int类型，e1大于e2返回>0,小于返回<0,=返回0
因为不知道使用者要排序什么类型,按照什么方式排序，所以要求使用qsort函数的使用者，自定义一个比较函数，qosrt默认排序是升序
陷阱:不能直接让e1和e2相比较,void*指针不能直接解应用,void*是无确切类型指针（垃圾桶），不知道访问几个字节
8.3 使用qsort排序整形数组
#include <stdlib.h>
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int cmp_int(const void* e1, const void* e2)//函数参数与我们要求保持一致
{
/*if (*(int*)e1 > *(int*)e2)
return 1;
else if (*(int*)e1 == *(int*)e2)
return 0;
else
return -1;*/
return (*(int*)e1 - *(int*)e2);//等价于上面的代码直接简化成这一句，升序
}
void test2()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);//0 1 2 3 4 5 6 7 8 9
}
int main()
{
test2();
return 0;
}8.4 使用qsort排序结构体
#include <stdlib.h>
struct Stu
{
char name[20];
int age;
double score;
};
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)//按照名字排序
{
return strcmp( ((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
//字符串之间不能用><比较，按照字典序的方式来比较，例如abce>abcd
}
void test3()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0} ,{"wangwu",10,90.0}};
int sz = sizeof(arr) / sizeof(arr[0]);
//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
int main()
{
test3();
return 0;
}8.3 基于冒泡排序，模拟实现库函数qsort
思路：qsort设计了四个参数有何意义？
void qsort
(
void *base, //待排序数据的起始地址
size_t num, //待排序数据元素个数
size_t width, //一个元素的字节大小
int ( *cmp )(const void *el, const void *e2 ) );//是函数指针，其中cmp是比较函数
//e1和e2是需要代比较的两个元素的地址，因为排序一定要知道哪个大哪个小
//函数指针返回值int类型，e1大于e2返回>0,小于返回<0,=返回0
1. qsort函数作者不知道我们需要排序什么类型数据，void* base能接受任意类型数据，代表了垃圾桶指针，要排序哪个数据把起始位置空间传过来即可
2.知道了起始地址，向后多少个数据我也需要知道，需要知道元素个数num
3.一个数据占多少个字节我也需要知道（width）
4.不同类型数据比较有差异，我们提取出来差异，让比较函数（以参数形式传递给qsort）用回调函数的方法实现排序
5.设计成const void*, 不知道要比较的两个函数具体类型 ，单纯比较不修改
6.交换的时候传宽度
函数主体
void bubble_sort(void* base, int num, int width,
int (*cmp)(const void*e1, const void*e2))
{
int i = 0;
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)
//找到当前元素和元素+1的地址传给cmp，比较，>0按照升序
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
//交换
}
}
}
}
交换函数
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)//一个一个字节交换
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
最终实现的模拟实现qsort，什么类型都能排序
int cmp_int(const void* e1, const void* e2)
{
return (*(int*)e1 - *(int*)e2);
}
struct Stu
{
char name[20];
int age;
double score;
};
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)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int width, int (*cmp)(const void* e1, const void* e2))
{
int i = 0;
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 test4()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
void test5()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
//bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test4();
test5();
return 0;
}
9.1 指针和数组面试题的解析
做题前你需要知道的：
数组名通常来说是数组首元素的地址，但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
3.sizeof是一个操作符sizeof 计算的是对象所占内存的大小-单位是字节,size_t，不在乎内存中存放的是什么，只在乎内存大小
4.strlen 库函数，求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
9.2 一维数组练习
//一维数组
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));
答案
printf("%d\n", sizeof(a));//4*4 = 16
printf("%d\n", sizeof(a + 0));//4/8 a+0是数组第一个元素的地址，是地址，大小就是4/8个字节
printf("%d\n", sizeof(*a)); //4 a表示数组首元素的地址，*a表示数组的第一个元素，sizeof(*a)就是第一个元素的大小-4
printf("%d\n", sizeof(a + 1));//4/8 a表示数组首元素的地址，a+1数组第二个元素的地址，sizeof(a+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是数组的地址，+1跳过整个数组，产生的4后边位置的地址
printf("%d\n", sizeof(&a[0]));//4/8 取出的数组第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));//4/8 数组第二个元素的地址
9.2 字符数组练习
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("%llu\n", sizeof(arr));//6
printf("%llu\n", sizeof(arr + 0));//4/8 arr + 0是数组首元素的地址
printf("%llu\n", sizeof(*arr));//1 - *arr是首元素，首元素是一个字符，大小是一个字节
printf("%llu\n", sizeof(arr[1]));//1 - arr[1]是数组的第二个元素，大小是1个字节
printf("%llu\n", sizeof(&arr));//4/8 &arr是数组的地址
printf("%llu\n", sizeof(&arr + 1));//4/8 &arr + 1是从数组地址开始向后跳过了整个数组产生的一个地址
printf("%llu\n", sizeof(&arr[0] + 1));//4/8 &arr[0] + 1 是数组第二个元素的地址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));
答案
printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));//错误- arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
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));//随机值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", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8 arr+0是数组首元素的地址
printf("%d\n", sizeof(*arr));//1 - *arr 数组的首元素
printf("%d\n", sizeof(arr[1]));//1 arr[1]数组的第二个元素
printf("%d\n", sizeof(&arr));//4/8 - &arr数组的地址，但是数组的地址依然是地址，是地址大小就是4/8
printf("%d\n", sizeof(&arr + 1));//4/8 - &arr + 1是\0后边的这个地址
printf("%d\n", sizeof(&arr[0] + 1));//4/8 - &arr[0] + 1是数组第二个元素的地址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));
答案
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
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
9.3 常量字符串练习
char *p = "abcdef";//存放的是字符串中a的首地址
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", sizeof(p));//4/8 p是指针变量，计算的是指针变量的大小
printf("%d\n", sizeof(p + 1));//4/8 p+1是'b'的地址
printf("%d\n", sizeof(*p)); //1 - *p 其实就是'a'
printf("%d\n", sizeof(p[0]));//1 - p[0]-> *(p+0)-> *p
printf("%d\n", sizeof(&p));//4/8 &p 是指针变量p在内存中的地址
printf("%d\n", sizeof(&p + 1));//4/8 - &p+1是跳过p之后的地址
printf("%d\n", sizeof(&p[0] + 1));//4/8 &p[0]是‘a’的地址，&p[0]+1就是b的地址
char *p = "abcdef";//存放的是字符串中a的首地址
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));
答案
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p + 1));//5 从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));//5 从b的位置开始向后数字符
9.4 二维数组练习
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]));
答案
printf("%d\n", sizeof(a));//计算的是整个数组的大小，单位是字节3*4*4 = 48
printf("%d\n", sizeof(a[0][0]));//4 第1行第一个元素的大小
printf("%d\n", sizeof(a[0]));//16 - a[0]是第一行的数组名，sizeof(a[0])就是第一行的数组名单独放在sizeof内部，计算的是第一行的大小
printf("%d\n", sizeof(a[0] + 1));//4/8 a[0]作为第一行的数组名，并没有单独放在sizeof内部，也没有被取地址，所以a[0]就是数组首元素的地址，就是第一行第一个元素的地址，a[0]+1就是第一行第二个元素的地址
printf("%d\n", sizeof(*(a[0] + 1)));//4 - *(a[0] + 1))表示的是第一行第二个元素
printf("%d\n", sizeof(a + 1));//4/8 - a表示首元素的地址，a是二维数组，首元素的地址就是第一行的地址，所以a表示的是二维数组第一行的地址，a+1就是第二行的地址
printf("%d\n", sizeof(*(a + 1)));//16 对第二行的地址解引用访问到就是第二行等价sizeof(a[1])
printf("%d\n", sizeof(&a[0] + 1));//4/8 - a[0]是第一行的数组名，&a[0]取出的就是第一行的地址，&a[0] + 1 就是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16 - 对第二行的地址解引用访问到就是第二行
printf("%d\n", sizeof(*a));//16 - a就是首元素的地址，就是第一行的地址，*a就是第一行
printf("%d\n", sizeof(a[3]));//16，sizeof不会访问内存，仅仅看数据类型，二维数组数据类型就是int [4]10.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;
}
思路：&a+1，数组地址加一跳过一个数组，把数组指针类型（int（*）5）强制类型转换成int*
*(ptr-1)跳到了5地址处，解应用
答案：2，5
10.2 结构体指针笔试题
假设p 的值为0x100000。 如下表表达式的值分别为多少？
已知，结构体Test类型的变量大小是20个字节
//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
int main()
{
p = (struct Test*)0x100000;
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}思路：1.结构体指针+1，+的是1*sizeof（结构体大小），在16进制0x100000上加20个字节，转换为16进制就是14
2.p被强制类型转换，变成整数，整数加1就是加1，指针类型+1才考虑加几个字节
10.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;
}
答案：4，2000000（以16进制打印）
10.4 笔试题练习
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p;
p = a[0];//没有放在sizeof内部，是首元素1的地址
printf( "%d", p[0]);//p[0] = *(p+0)
return 0;
}思路：内部是逗号表达式，逗号表达式结果是最后一个数
int a[3][2] = {1,3,5,0,0,0};答案：1
10.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;
} 
思路：指针-指针，得到的指针之间的元素个数 ，其中低地址-高地址，得到负数
-4 以%p形式打印
原码：10000000000000000000000000000100
反码：11111111111111111111111111111011
补码：11111111111111111111111111111100
转换成16进制 FF FF FF FC答案：FF FF FF FC -4
10.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;
}
思路：&aa+1跳过一个数组，强转成int*
*（aa+1），aa是第一行的地址，+1来到第二行，解应用得到第二行第一个元素
答案：10，5
10.7 笔试题练习
#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
答案：at
10.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;
}