傻傻分不清sizeof和strlen？？and今天：指针四--数组和指针笔试题
1. sizeof和strlen的对⽐
1.1 sizeof
sizeof计算变量所占内存内存空间⼤⼩的，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。
sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。
#inculde
int main()
{
int a = 10;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof a);//()可以省略
printf("%d\n", sizeof(int));
return 0; } 
1.2 strlen
strlen 是C语⾔库函数，功能是求字符串⻓度。函数原型如下：
size_t strlen ( const char * str );统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。
strlen 函数会⼀直向后找 \0 字符，直到找到为⽌，所以可能存在越界查找。
#include
#include
int main()
{
char arr1[3] = {'a', 'b', 'c'};
char arr2[] = "abc";//"abc\0"
printf("%zd\n", strlen(arr1));//随机数
printf("%zd\n", strlen(arr2));//3
printf("%zd\n", sizeof(arr1));//3
printf("%zd\n", sizeof(arr2));//4
return 0;
} 
1.3 sizeof 和 strlen的对⽐
sizeof
1. sizeof是操作符
2. sizeof计算操作数所占内存的⼤⼩，单位是字节
3. 不关注内存中存放什么数据
strlen
1. strlen是库函数，使⽤需要包含头⽂件 string.h
2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的个数
3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界
1.4 深层次理解举例
1.sizeof在计算大小时，是根据类型推算的。
2.sizeof的操作数如果是一个表达式，表达式的不参与计算的！！！
#include
int main()
{
short a = 10;//占2个字节
int i = 20;//占4个字节
int n = sizeof(a = i + 4);//截断---没开始计算就先编译打印了
printf("%d\n", a);
printf("%d\n", n);
return 0;
} 
为什么表达式放到sizeof（）内部，表达式不参与计算？
表达式有2个属性：
1.值属性
2.类型属性
2. 数组和指针笔试题解析
数组名的意义：
1. sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩。
2. &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址。
3. 除此之外所有的数组名都表⽰⾸元素的地址。
2.1 ⼀维数组
int a[] = {1,2,3,4};
printf("%zd\n",sizeof(a));
//16
printf("%zd\n",sizeof(a+0));//没有单独放到sizeof内部-->不是整个数组
//首元素地址，地址大小就是4/8个字节
//a+0==&a[0]
printf("%zd\n",sizeof(*a));//a是首元素地址，a==&a[0]
//*a就是首元素，就是a[0]，大小是4个字节
printf("%zd\n",sizeof(a+1));//a是首元素地址，a+1-->&a[1]
//就是第二个元素的地址，地址大小就是4/8个字节
printf("%zd\n",sizeof(a[1]));//就是第二个元素
//大小4个字节
printf("%zd\n",sizeof(&a));//&a就是整个数组地址
//地址大小就是4/8个字节
printf("%zd\n",sizeof(*&a));//&a就是整个数组地址
//*和&相抵，取地址然后解引用-->数组所有元素，大小是16
printf("%zd\n",sizeof(&a+1));//&a+1-->跳过整个数组后的地址
//地址大小就是4/8个字节
printf("%zd\n",sizeof(&a[0]));//首元素的地址
//地址大小就是4/8个字节
printf("%zd\n",sizeof(&a[0]+1));//第二个元素地址
//地址大小就是4/8个字节
2.2 字符数组
char arr[] = {'a','b','c','d','e',‘f’}
printf("%zd\n", sizeof(arr));//6
printf("%zd\n", sizeof(arr+0));//arr--首元素地址，arr+0--首元素地址
//地址大小就是4/8个字节
printf("%zd\n", sizeof(*arr));//首元素
//占1个字符大小就是1个字节
printf("%zd\n", sizeof(arr[1]));//第二个元素
//占1个字符大小就是1个字节
printf("%zd\n", sizeof(&arr));//取整个数组地址
//地址大小就是4/8个字节
printf("%zd\n", sizeof(&arr+1));//取跳过整个数组后面的地址
//地址大小就是4/8个字节
printf("%zd\n", sizeof(&arr[0]+1));//第二个元素地址
//地址大小就是4/8个字节char arr[] = {'a','b','c','d','e','f'}
printf("%zd\n", strlen(arr));//随机值
//数组没有明确给出\0
printf("%zd\n", strlen(arr+0));//等同于arr
//随机值
printf("%zd\n", strlen(*arr));//首元素--->'a'--->97
//strlen不管接收到什么，都当做地址--->非法访问（error）
printf("%zd\n", strlen(arr[1]));//第二个元素'b'--->98
//非法访问（error）
printf("%zd\n", strlen(&arr));//整个数组地址
//不确定\0的位置-->随机值
printf("%zd\n", strlen(&arr+1));//获得跳过整个数组的地址
//随机值
printf("%zd\n", strlen(&arr[0]+1));//第二个元素地址
//无法确定-->随机值char arr[] = "abcdef";
//[a b c d e f \0]
printf("%zd\n", sizeof(arr));//7
printf("%zd\n", sizeof(arr+0));//arr-->首元素地址
//arr+0也是首元素地址，是地址大小就是4/8个字节
printf("%zd\n", sizeof(*arr));//首元素
//大小1个字节
printf("%zd\n", sizeof(arr[1]));//第二个元素
//大小1个字节
printf("%zd\n", sizeof(&arr));//整个数组地址
//地址大小就是4/8个字节
printf("%zd\n", sizeof(&arr+1));//获得跳过整个数组的地址
//地址大小就是4/8个字节
printf("%zd\n", sizeof(&arr[0]+1));//第二个元素地址
//地址大小就是4/8个字节char arr[]="abcdef";
//[a b c d e f \0]
printf("%lld\n", strlen(arr));//6
printf("%lld\n", strlen(arr+0));//首元素地址
//strlen从起始位置向后找\0
//6
printf("%lld\n", strlen(*arr));//首元素
//非法访问（error）
printf("%lld\n", strlen(arr[1]));//第二个元素
//非法访问（error）
printf("%lld\n", strlen(&arr));//&a-->整个数组地址,但是这个地址也指向数组的起始位置
//strlen从起始位置向后找\0
//6
printf("%lld\n", strlen(&arr+1));//跳过整个数组地址，从这里开始找\0
//随机值
printf("%lld\n", strlen(&arr[0]+1));//第二个元素地址
//从第二个开始向后找\0
//5char *p = "abcdef";
//[a b c d e f \0]
//p放着字符串的首元素地址
printf("%lld\n", sizeof(p));//p-->指针变量
//大小是4/8个字节
printf("%lld\n", sizeof(p+1));//p+1-->第二个字符地址
//地址大小就是4/8个字节
printf("%lld\n", sizeof(*p));//首字符
//大小1个字节
printf("%lld\n", sizeof(p[0]));//首字符
//大小1个字节
printf("%lld\n", sizeof(&p));//&p是p的地址
//地址大小就是4/8个字节
printf("%lld\n", sizeof(&p+1));//跳过p后的地址
//地址大小就是4/8个字节
printf("%lld\n", sizeof(&p[0]+1));//第二个字符的地址
//地址大小就是4/8个字节char *p = "abcdef";
//[a b c d e f \0]
printf("%lld\n", strlen(p));//p存放的是首字符（a）的地址，从a的地址开始向后查找\0
//6
printf("%lld\n", strlen(p+1));//b的地址开始向后查找\0
//5
printf("%lld\n", strlen(*p));//非法访问（error）
printf("%lld\n", strlen(p[0]));//非法访问（error）
printf("%lld\n", strlen(&p));//，&p整个数组地址，从p所占空间的起始位置开始向后查找\0
//随机值
printf("%lld\n", strlen(&p+1));//跳过整个数组的地址查找\0
//随机值
printf("%lld\n", strlen(&p[0]+1));//b的地址开始向后查找\0
//52.3 ⼆维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));//计算整个数组大小
//48个字节
printf("%d\n",sizeof(a[0][0]));//第一行第一个元素
//4个字节
printf("%d\n",sizeof(a[0]));//第一行的数组名
//单独放在sizeof内部，计算的是第一行数组大小
/16个字节
printf("%d\n",sizeof(a[0]+1));//a[0]没有单独放在sizeof内部--->首元素a[0][0]的地址
a[0]+1-->第一行第二个元素a[0][1]地址
//地址大小就是4/8个字节
printf("%d\n",sizeof(*(a[0]+1)));//第一行第二个元素
//4个字节
printf("%d\n",sizeof(a+1));//a没有单独放在sizeof内部--->首元素a[0]的地址-->第一行的地址
//a+1-->第二行的地址
//地址大小就是4/8个字节
printf("%d\n",sizeof(*(a+1)));//第二行的元素
//16个字节
printf("%d\n",sizeof(&a[0]+1));//&a[0]-->取出第一行的地址，&a[0]+1-->得到第二行的地址
//地址大小就是4/8个字节
printf("%d\n",sizeof(*(&a[0]+1)));//第二行的元素
//16个字节
printf("%d\n",sizeof(*a));//a是首元素地址，也就是第一行的地址，*a-->第一行的元素
//16个字节
printf("%d\n",sizeof(a[3]));//某一行的元素-->sizeof不参与运算
//16个字节3. 指针运算笔试题解析
3.1 题⽬1
#include
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));//2 5
return 0;
} 3.2 题⽬2
//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结构是啥？
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
printf("%p\n", p + 0x1);//+1-->x86环境下+20-->0x100014
printf("%p\n", (unsigned long)p + 0x1);//强制类型转换成无符号长整型
//+1-->+1-->0x100001
printf("%p\n", (unsigned int*)p + 0x1);//强制类型转换成无符号整型指针变量
//+1-->+4-->0x100004
return 0;
}
3.3 题⽬3
#include
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };//逗号表达式
//逗号表达式：从左向右计算，但是整个表达式的结果是最后一个表达式的结果，以（ ）划分
//实际a数组：1 3
// 5 0
// 0 0
int *p;
p = a[0];//p存放a[0]首元素地址，a[0][0]
printf( "%d", p[0]);//1
return 0;
} 3.4 题⽬4
//假设环境是x86环境，程序输出的结果是啥？
#include
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]);//-4对应的地址，-4
return 0;
} 
3.5 题⽬5
和题目一类似
#include
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));//aa+1-->第二行地址
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10 5
return 0;
} 3.6 题⽬6
#include
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;//pa存放首元素地址
pa++;//第二个元素地址
printf("%s\n", *pa);//at
return 0;
} 3.7 题⽬7
#include
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);//++cpp-->跳过1个char***大小
printf("%s\n", *--*++cpp+3);//在上次基础上++cpp
printf("%s\n", *cpp[-2]+3);//*（*（cpp-2））+3
//cpp[-2]执行时，cpp的值不变
//只是cpp-2表达式对应这个位置，下次执行时，cpp指向的位置不变，依旧是第二次cpp对应的位置
printf("%s\n", cpp[-1][-1]+1);//*（*（cpp-1）-1）+3
return 0;
} **++cpp
*--*++cpp+3
*cpp[-2]+3
cpp[-1][-1]+1
PS：小江目前只是个新手小白。欢迎大家在评论区讨论哦！有问题也可以讨论的！
如果对你有帮助的话，记得点赞+收藏⭐️+关注➕
