写点什么

揭秘 C 语言的心脏:深入探索指针与数组的奥秘

  • 2024-02-02
    福建
  • 本文字数:5155 字

    阅读完需:约 17 分钟

1. strlen()和 sizeof 的区别



2. 数组名的理解


  1. sizeof(数组名),数组名单独放在括号里,这⾥的数组名表⽰整个数组,计算的是整个数组的⼤⼩。

  2. &数组名,这⾥的数组名表⽰整个数组,取出的是整个数组的地址。

  3. 除此之外所有的数组名都表⽰⾸元素的地址。


3. 一维数组


3.1 题目


int main(){	//输出结果?	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));	return  0;}
复制代码


3.2 输出结果



  • 该环境为 VS2022,×64 环境。后续也会在该环境下实验


3.3 解析


  1. sizeof(a),这⾥的 a 是数组名表⽰整个数组,计算整个数组的大小,数组每个元素是整型,一共有四个元素。所以 4*4=16

  2. a+0 是个表达式,这时 a 就是数组首元素地址,a+0 仍是首元素地址,地址在×86 环境下大小为 4,在×64 环境下大小为 8

  3. a 是数组首元素地址,对 a 解引用得到 1,1 是整型,所以大小为 4

  4. a 是数组首元素地址,a+1 是第二个元素的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  5. a[1]是数组第二个元素 2,是一个整型,大小为 4

  6. &a 是对数组名取地址,代表整个数组的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  7. &a 的 &和*相互抵消,相当于 sizof(a),也就是第一步,大小为 16

  8. &a+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,仍是地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  9. &a[0]就是数组首元素的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  10. &a[0]+1 就是第二个元素地址,与 a+1 等价,在×86 环境下大小为 4,在×64 环境下大小为 8


4. 字符数组


4.1 题目一


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;}
复制代码


(1) 输出结果



(2) 解析


  1. sizeof(arr),这⾥的 arr 是数组名表⽰整个数组,计算整个数组的大小,数组每个元素是字符型,一共 6 个元素,1*6=6

  2. a+0 是个表达式,这时 a 就是数组首元素地址,a+0 仍是首元素地址,地址在×86 环境下大小为 4,在×64 环境下大小为 8

  3. arr 是数组首元素地址,对 arr 解引用得到 a,a 是字符型,所以大小为 1

  4. arr[1]是数组第二个元素 b,大小为 1

  5. &arr 是对数组名取地址,代表整个数组的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  6. &arr+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,仍是地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  7. &arr[0]+1 就是第二个元素地址,与 arr+1 等价,在×86 环境下大小为 4,在×64 环境下大小为 8


4.2 题目二


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[0] + 1));         printf("%d\n", strlen(*arr));	printf("%d\n", strlen(arr[1]));	return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. strlen 是以'\0'为标志的,如果数组里没有,会继续往内存中寻找,直到找到'\0',所以是个随机值

  2. arr+0 也是首元素地址,与 1 同理,所以也是随机值

  3. &arr 是对数组名取地址,代表整个数组的地址,为了存储方便也会以数组首元素的地址表示,所以和 1.2 值相同,也是个随机值

  4. &arr+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,不知道'\0'在哪,所以也是随机值

  5. &arr[0]+1 就是第二个元素地址,一直找到内存中的\0',是个随机值且会比 1 的长度少一

  6. strlen 的参数要传地址进去,否则就会出错

  7. strlen 的参数要传地址进去,否则就会出错


4.3 题目三


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;}
复制代码


(1) 输出结果



(2) 解析


  1. sizeof(arr),计算整个数组的大小,字符串默认的结束标志为'\0',所以数组一共有 7 个元素,每个元素都是字符型,1*7=7

  2. arr+0 是个表达式,这时 arr 数组首元素地址,arr+0 仍是首元素地址,地址在×86 环境下大小为 4,在×64 环境下大小为 8

  3. arr 是数组首元素的地址,对其解引用等到第一个元素 a,a 为字符型,大小为 1

  4. arr[1]是数组第二个元素 b,大小也为 1

  5. &arr 是对数组名取地址,代表整个数组的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  6. &arr+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,仍是地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  7. &arr[0]+1 就是第二个元素地址,与 arr+1 等价,在×86 环境下大小为 4,在×64 环境下大小为 8


4.4 题目四


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[0] + 1));	printf("%d\n", strlen(*arr));	printf("%d\n", strlen(arr[1]));	return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. strlen 是以'\0'为标志的,字符串默认结束标志位'\0',所以是 6

  2. arr+0 也是首元素地址,与 1 同理,所以也是 6

  3. &arr 是对数组名取地址,代表整个数组的地址,为了存储方便也会以数组首元素的地址表示,所以和 1.2 值相同,也是 6

  4. &arr+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,不知道'\0'在哪,所以是随机值

  5. &arr[0]+1 就是第二个元素地址,一直找到内存中的\0',会比 1 的长度少一,是 5

  6. strlen 的参数要传地址进去,否则就会出错

  7. strlen 的参数要传地址进去,否则就会出错


4.5 题目五


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 + 1));	printf("%d\n", sizeof(&p[0] + 1));	printf("%d\n", sizeof(*p));	printf("%d\n", sizeof(p[0]));	return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. 字符串存储的是首元素地址,所以 p 相当于首元素地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  2. 同理 p+1 是第二个元素的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  3. 对 p 取地址,相当于得到还是地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  4. &arr+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,仍是地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  5. &p[0]+1 就是第二个元素地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  6. *p 与 p[0]都是第一个元素,大小为 1


4.6 题目六


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 + 1));	printf("%d\n", strlen(&p[0] + 1));	printf("%d\n", strlen(*p));	printf("%d\n", strlen(p[0]));
return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. strlen 是以'\0'为标志的,字符串默认结束标志位'\0',所以是 6

  2. p+1 就是第二个元素地址,一直找到内存中的\0',会比 1 的长度少一,是 5

  3. &p 是对数组名取地址,代表整个数组的地址,为了存储方便也会以数组首元素的地址表示,所以和 1 值相同,也是 6

  4. &p+1 指的是以整个数组的地址为单位,跳过整个数组之后的地址,不知道'\0'在哪,所以是随机值

  5. &p[0]+1 就是第二个元素地址,一直找到内存中的\0',会比 1 的长度少一,是 5

  6. *p 与 p[0]都是第一元素。strlen 的参数要传地址进去,否则就会出错


5. 二维数组


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;}
复制代码


(1) 输出结果



(2) 解析


  1. sizeof(a),这⾥的 a 是数组名表⽰整个数组,计算整个二维数组的大小,数组每个元素是整型型,一共 12 个元素,12*4=48

  2. a[0][0]是指二维数组第一个元素,是个整型,大小为 4

  3. a[0]相当于第一排首元素的地址,在二维数组中这里可以抽象理解为一维数组的数组名,单独放在 sizeof 中,所以 4*4=16

  4. a[0]+1 是一个表达式,代表第一排第二个元素的地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  5. a[0]相当于第一排首元素的地址,*a[0]就是首元素,大小为 4

  6. a 第一排的地址,a+1 是第二排地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  7. *(a+1)等价于 a[1],相当于第二排的数组名,4*4=16

  8. &a[0] + 1 等价于 a=1,即第二排地址,在×86 环境下大小为 4,在×64 环境下大小为 8

  9. *(&a[0] + 1))等价于*(a+1),与 7 相同,大小为 16

  10. *a 相当于第一排的数组名,大小也为 16

  11. 因为 sizeof 只是根据类型判断,所以不会管是否越界,所以仍相当于一排的数组名,大小为 16



6. 指针深度理解


6.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;}
复制代码


(1) 输出结果



(2) 解析


  1. a 是首元素的地址,a+1 是指第二个元素的地址,对其解引用就是第二个元素,也就是 2

  2. &a+1 跳过整个数组,在被强制类型转换为 int*,减 1 指向 5,解引用就是 5



6.2 题目二


#include<stdio.h>//在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);	printf("%p\n", (unsigned long)p + 0x1);	printf("%p\n", (unsigned int*)p + 0x1);	return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. p 的地址是 0x100000,是十六进制表示,加 1 跳过一个结构体大小(20),十六进制表示就是 00100014

  2. p 被强制类型转换为无符号长整型,加 1 相当于加上数字 1,就为 00100001

  3. p 被强制类型转换为无符号整型的指针,加 1 跳过一个整型,为 00100004


6.3 题目三


#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;}
复制代码


(1) 输出结果



(2) 解析


  1. 括号表达式从左往右依次计算,取最后一次的值,所以数组中元素简化为 1,3,5

  2. p[0]就是数组的首元素,为 1


6.4 题目四


//假设环境是x86环境,程序输出的结果是啥?#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;}
复制代码


(1) 输出结果



(2) 解析


  1. 首先我们得知道数组在内存中是连续存储的

  2. p 的类型为 int(*p)[4],p[4][2]等价于*(*(p+4)+2),也就是说把 p 跳过 4 个以 int(*p)[4]类型的距离,跳过 2 个整型

  3. 示意图如下,蓝色代表 p[4][2],红色代表 a[4][2]



  1. &p[4][2] - &a[4][2]之间差四个元素,值为-4,又因为地址是无符号的整数,所以发生整型提升



6.5 题目五


#include <stdio.h>//输出什么?int main(){	char* a[] = { "work","at","alibaba" };	char** pa = a;	pa++;	printf("%s\n", *pa);	return 0;}
复制代码


(1) 输出结果



(2) 解析


  1. 这是一个指针数组,每个元素类型为 char*,分别指向一个字符串,如图



  1. pa++跳过一个 char*的地址指向第二个元素,对其解引用得到 at


6.6 题目六


#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;}
复制代码


(1) 输出结果



(2) 解析


  1. 由图可知 cpp++指向 c+2,再两次解引用得到"POINT"的首元素地址



  1. cpp 先++指向 c+1,解引用得到 c+1,再--得到 c 解引用得到 ENTER 的首元素地址,+3 得到 E 的地址



  1. *cpp[-2]等价于**(cpp-2),cpp-2 指向 c+3,两次解引用得到 FIRST 的首元素地址,+3 得到 S 的地址



  1. cpp[1][-1]等价于*(*(cpp-1)-1),这时候 cpp 指向的是第一个 c,cpp-1 再解引用得到 c+2,再-1 解引用得到 NEW 的地址,最好加 1 得到 E 的地址



文章转载自:Betty’sSweet

原文链接:https://www.cnblogs.com/bett/p/18001744

体验地址:http://www.jnpfsoft.com/?from=001

用户头像

还未添加个人签名 2023-06-19 加入

还未添加个人简介

评论

发布
暂无评论
揭秘C语言的心脏:深入探索指针与数组的奥秘_Java_不在线第一只蜗牛_InfoQ写作社区