C语言系列——第十节-指针的进阶（进阶）（2.3万字）
指针的进阶
- 1. 字符指针
- 2. 指针数组
-
-
- 指针数组的定义
-
- 3. 数组指针
-
- 3.1 数组指针的定义
- 3.2 &数组名VS数组名
- 3.3 数组指针的使用
-
- 谁来接收二维数组
-
- 二维数组的首元素是一个数组
- 数组指针的首元素可以是一个数组
- 4. 数组参数、指针参数
-
- 4.1 一维数组传参
- 4.2 二维数组传参
- 4.3 一级指针传参
- 4.4 二级指针传参
- 5. 函数指针
- 6. 函数指针数组
-
- 补充：函数指针，就是把函数名加*
- 补充：函数指针数组，就是再加【】，变成数组优先级高
- 7. 指向函数指针数组的指针
-
- 函数名再加括号加*
- 8. 回调函数
-
- 自定义qsort函数
- qsort函数中的 比较函数
- 9. 指针和数组笔试题解析
- 10. 指针笔试题
-
- 笔试题1：
- 笔试题2（指针+-整数，注意指针类型）
- 笔试题3
-
- 数组的地址，对应数组内存的地址
- 数组内存 小端存储，十六进制
- 一个字节，二个十六进制
- 笔试题4
- 笔试题5（-4的%p的输出）
- 笔试题6
- 笔试题7
- 笔试题8（关键清楚数组里存放的是什么）
指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
这个章节，我们继续探讨指针的高级主题。
1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char*
一般使用:
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
还有一种使用方式如下：
int main()
{
const char* pstr = "hello bit.";//这里是把
//一个字符串放到pstr指针变量里了吗？
/*不是，而是把字符串首元素h的地址放在了pstr指针中*/
printf("%s\n", pstr);
return 0;
}
代码 const char* pstr = "hello bit.";
特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello bit. 首字符的地址放到了pstr中。
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。
那就有可这样的面试题：
#include 这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当
几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。所以str3和str4相同。
但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同。
2. 指针数组
在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
补充；
- 指针数组是存放指针的数组，本质是数组。
- 数组名表示首元素的地址（当然有两个例外，1个是sizeof+数组名时 2.&+数组名的时候）
- 数组名是首元素地址，那么数组名±整数 也就是 跨越的是地址 举例 arr1 + 2 也就是指向了arr1 数组的第二个元素。再解引用，就找到了第二个元素的值，也就是
*（arr1 + 1）- 但是呢，如果指针数组，存放的第一个元素，虽然是地址，但是 是另一个数组 首元素的地址呢
#include分析这样的情况，牢记数组名是首元素地址即可
指针数组的定义
int * a【】，这样是不可以的 1.即没有指定大小
2.或者也没初始化
#include3. 数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？
//p1, p2分别是什么？
int *p1[10]; /*指针数组，首先看数组名是p1，p1的
类型是 int* 【】 由此可以得出这是一个存放指针的
数组*/
int (*p2)[10];/*数组指针，首先看数组名*p2，*p2的
类型是 int(*)【】 由此可以得出这是一个存放int整型的指针*/
解释：
int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
3.2 &数组名VS数组名
对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：
#include 
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
#include 
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
3.3 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：
#include 谁来接收二维数组
二维数组的首元素是一个数组
数组指针的首元素可以是一个数组
#include 补充：
数据的读入方式
1.二维数组 p[ ][ ] 用括号
2.用解引用* 就牢记数组名是首元素地址，看清数组名是什么就好了（数组名本身有没有指针）
学了指针数组和数组指针我们来一起回顾并看看下面代码的意思
int arr[5]; 一维整型数组
int *parr1[10]; 指针数组
int (*parr2)[10]; 数组指针
int (*parr3[10])[5]; 存放数组指针的数组（因为
先看数组名parr3先与【10】集合，然后那么就是数组类型。
数组的元素是*
指针又指向数组，所以是数组指针
数组的类型为 int （*括号里的结合性高）【5】那么说明，数组存放数组指针）
4. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.1 一维数组传参
#include 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 一级指针传参
#include 思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：
void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？
4.4 二级指针传参
#include 思考：
当函数的参数为二级指针的时候，可以接收什么参数?
void test(char **p) {
}
int main()
{
char c = 'b';
char*pc = &c;
char**ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);//Ok? 可以的，因为arr首元素是一级指针
//的地址，
return 0; }
5. 函数指针
首先看一段代码：
#include 
输出的是两个地址，这两个地址是 test 函数的地址。
那我们的函数的地址要想保存起来，怎么保存？
下面我们看代码：
void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void* pfun2();
首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？
pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
补充（函数类型如何表示）：
void (*pfun1)() 类型：
void（*）（）
int （*ph）（int p） 类型：
int （*）（int）
阅读两段有趣的代码：
//代码1
(*(void (*)())0)();
由上得，void (*)()是一个函数类型
0则是地址为0，所以这是一个对0的强制类型转换 第一个*
可有可无
//代码2
void (*signal(int , void(*)(int)))(int);
这个出现函数名了，首先得知，是一个函数声明
signal的函数名，函数的参数是(int , void(*)(int))
函数的返回值是 void（*）（int）
代码2太复杂，如何简化：
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);
6. 函数指针数组
补充：函数指针，就是把函数名加*
补充：函数指针数组，就是再加【】，变成数组优先级高
数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，
比如：
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
三个函数指针数组的定义
类似于 指针数组
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
答案是：parr1
parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。
函数指针数组的用途：转移表
例子：（计算器）
#include 使用函数指针数组的实现
#include 7. 指向函数指针数组的指针
函数名再加括号加*
指向函数指针数组的指针是一个 指针
指针指向一个 数组 ，数组的元素都是 函数指针
void test(const char* str) {
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0; }
8. 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
首先演示一下qsort函数的使用：
qsort是一种库函数，（
第一个参数，是需要排序的第一个元素的地址，
第二个参数是需要排序的个数，
第三个参数是每个元素的字节数，
第四个参数是比较函数（不同类型的比较，比较函数是内容是不同的）
需要注意的是，qsort的传入的最后一个参数，是一个比较两个数值大小的函数，按着顺序比较的话，返回如果是大于0，那么qsort就是按着从小到大的顺序排列。
如果不是按着顺序比较，返回值大于0，则qsort就是按着从大到小的顺序排列。
如何理解：
因为比较函数返回值如果大于0，那么qsort中就会交换两个数据，那么就看什么造成了比较函数的返回值是大于0就可以看出，是从小到大，还是从大到小排序
示例一下：如何由小到大，和由大到小排序
compare比较函数，e1的地址，和e2 的地址是按顺序传入的
比较的时候，也是e1 - e2这个时候，如果e1 > e2 那么就
会交换数值，所以能 1. 我们用 e2 - e1 或者 2.让e1
< e2 进行交换
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);
}
具体如下（自行定义的一个qsort）
自定义qsort函数
void myqsort(void * base, size_t nitems, size_t size, int(*compar)(const void *, const void *))
{
/*首先用void接受地址，是因为为了所有数据类型的地址都
可以传进来*/
int i, j;
char * st = (char *)base;
/*void *不方便加减，用char *加减轻松且字节跳转为1，
方便控制。*/
char tmp[16]; //考虑到long double类型，临时空间做成16字节比较保险
for (i = 0; i < nitems - 1; i++)
//传入多少个需要改变的元素个数，就根据这个冒泡
{
for (j = 0; j < nitems - 1 - i; j++) //冒泡常用循环头
{
if (compar(st + j * size, st + (j + 1) * size))
//比较函数，传入需要改变的地址，
/*比较的时候跳转注意乘size，因为都是char*的地址，
char*指针加减，的时候跨度，是按着一个字节跨动的
所以我们需要乘以size，便于指针精确移动*/
{
memcpy(tmp, st + j * size, size); //交换操作用memcpy完成就不会出问题。
memcpy(st + j * size, st + (j + 1) * size, size);
memcpy(st + (j + 1) * size, tmp, size);
}
}
}
}
qsort函数中的 比较函数
整形比较
int int_cmp(const void * p1, const void * p2) {
return (*( int *)p1 - *(int *) p2);
}
返回值是大于0，qsort中运行，而返回值大于0的时候，
是p1的值大于0的时候，所以 是从小到大排序
结构体比较
结构体按年龄比较
int cmp_stu_by_age(const void* e1, const void*e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
结构体按名字ascll值比较
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp( ((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
}
#include 使用回调函数，模拟实现qsort（采用冒泡的方式）。
注意：这里第一次使用 void* 的指针，讲解 void* 的作用
9. 指针和数组笔试题解析
//一维数组
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));
//字符数组
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));
//二维数组
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]));
数组名是什么呢？
数组名通常来说是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
int main()
{
//int a[] = { 1,2,3,4 };
// 0 1 2 3
//int (*p)[4] = &a;
//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 数组第二个元素的地址
//字符数组
//char arr[] = { 'a','b','c','d','e','f' };//[a b c d e f]
//printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
//printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
printf("%d\n", strlen(arr[1]));//err -'b' - 98
//printf("%d\n", strlen(&arr));//随机值
//printf("%d\n", strlen(&arr + 1));//随机值
//printf("%d\n", strlen(&arr[0] + 1));//随机值
64位平台下 \0的出现 和 82位下 \0的出现不一样
且 sizeof的返回值是 long long unsigned类型
//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 是数组第二个元素的地址
return 0;
}
sizeof是一个操作符
sizeof 计算的是对象所占内存的大小-单位是字节,size_t
不在乎内存中存放的是什么，只在乎内存大小
strlen 库函数
求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
int main()
{
//char arr[] = { 'a', 'b', 'c','d', 'e', 'f' };
//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
//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 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* p = "abcdef";
//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的位置开始向后数字符
//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的地址
//二维数组
int a[3][4] = { 0 };
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 对第二行的地址解引用访问到就是第二行
//*(a+1) -> a[1]
//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就是第一行
//*a - > *(a+0) -> a[0]
printf("%d\n", sizeof(a[3]));//16 int [4]
//int a = 10;
//printf("%d\n", sizeof(a));//4
//printf("%d\n", sizeof(int));//4
return 0;
}
总结：
数组名的意义：
- sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
- &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
- 除此之外所有的数组名都表示首元素的地址。
sizeof
返回数据所占内存的大小，单位是字节
strlen
给一个地址，从该地址开始查询，数据为0的值，之间的元素个数
数组名是什么呢？
数组名通常来说是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
int main()
{
int a[] = { 1,2,3,4 };
0 1 2 3
int (*p)[4] = &a;
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 数组第二个元素的地址
字符数组
char arr[] = { 'a','b','c','d','e','f' };//[a b c d e f]
printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
printf("%d\n", strlen(arr[1]));//err -'b' - 98
printf("%d\n", strlen(&arr));//随机值
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&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 是数组第二个元素的地址
return 0;
}
sizeof是一个操作符
sizeof 计算的是对象所占内存的大小-单位是字节,size_t
不在乎内存中存放的是什么，只在乎内存大小
strlen 库函数
求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
int main()
{
char arr[] = { 'a', 'b', 'c','d', 'e', 'f' };
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
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 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* p = "abcdef";
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的位置开始向后数字符
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的地址
二维数组
int a[3][4] = { 0 };
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 对第二行的地址解引用访问到就是第二行
*(a+1) -> a[1]
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就是第一行
*a - > *(a+0) -> a[0]
printf("%d\n", sizeof(a[3]));//16 int [4]
int a = 10;
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(int));//4
return 0;
}
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; }
//程序的结果是什么？
2 5
分析
&a表示取整个数组的地址
&a+1 表示的是数据5 后面的地址
之后再 强制类型转换（int *）之后+1 就的加的就是1个int
笔试题2（指针±整数，注意指针类型）
1个字节=2个十六进制
1个十六进制=4个比特位
补充
- %p 是打印地址，按着16进制打印8个16进制
- 普通数据类型 ± 正常
- %x 把数据按着16进制的形式输出
//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
p = (struct Test*)0x100000;
/* 注意此时p是结构体指针，+=的时候跨度由结构体变量的
大小决定 */
printf("%p\n", p + 0x1);所以这个加1，加的是20个
字节
printf("%p\n", (unsigned long)p + 0x1);
此时被转成long型，所以加1，加的就是1
printf("%p\n", (unsigned int*)p + 0x1);
此时被转成int指针，+1就是 加4个字节
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;
}
/*关键如何分析出a首元素的内存（小端存储，十六进制）
01000000 02000000 03010000 04000000*/
&a取得是整个数组的地址，+1便是指向了数据4的后面
（int）a是把a的首元素地址转化成int类型
首先就要找到a首元素的地址，然后+1，那么此时得到的数
据**也是一个地址（很重要）**，并且是a首元素的地址，
加上1个字节后所指向的位置（补充按着int指针加1应该
是加4个字节，那也就是指向a【1】了）但是此时不是指向
a【1】，而就是单单是
a【0】的地址+1个字节（此时就需要小端存储知识了，如
下图）（此时得到的地址，所指向的内容如下图）
关键：数组的地址，对应数组内存的地址
所以(int)a + 1得到得值，指向得就是蓝色框里得内容
由于是小端存储，那么2就变成了最大值
输出结果：4,2000000
笔试题4
括号表达式，得到的是括号里最后一个值
#include 笔试题5（-4的%p的输出）
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
-4的按着地址的形式输出
是按着-4的补码进行打印
笔试题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 是对二维数组aa整个取地址，+1后则指向10后面的地址
aa 是对二维数组首元素取地址，二维数组的首元素是第一行的地址，+1后则指向第二行的地址也就是指向6
最后根据输出 *(ptr1 - 1), *(ptr2 - 1)
此时已经被强制类型转换 +-处理都是按着int跨度的。
所以最后指向的数据 分别是 10，和 5
笔试题7
#include 笔试题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; }
c输出存放的是 一级指针地址
cp存放的是 二级指针地址
cpp 存放的是 三级指针地址
cpp++ 则cpp表示指向cp的第二个元素地址，再把cpp解引用
找到cp第二个元素的地址，再解引用 找到c的第三个元素的地址
所以输出POINT
*--*++cpp+3（注意顺序，+3是最后的）首先对cpp++得到
cpp表示指向cp的第！三！个元素地址（因为上面已经加过）
解引用后表示 找到cp的第三个元素地址，然后--表示cp第三
个元素所指向的数组--，也就是cp的第三个元素指向了ENTER
然后解引用后再加3表示 只输出 ER
*cpp[-2]+3
cpp[-2]表示指向指向cp的第一个元素地址，再解引用然后就
指向FIRST，再+3 输出ST
cpp[-1][-1]+1
cpp-1 表示cpp指向cp的第二个元素，然后再【-1】，
表示cp中第二个元素原本指向c的第三个元素，现在就指向
第二个元素，NEW，再+1 表示就输出 EW