[C]基础13.深入理解指针(5)

• 博客主页：向不悔
• 本篇专栏：[C]
• 您的支持，是我的创作动力。

---

---

0、总结

1、sizeof和strlen的对比

1.1 sizeof

sizeof计算变量所占内存内存空间大小的，单位是字节。如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。sizeof只关注占用内存空间的大小，不在乎内存中存放什么数据。如下：

#include <stdio.h>
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 <stdio.h>
int main()
{char arr1[3] = { 'a','b','c' };char arr2[] = "abc";printf("%d\n", strlen(arr1));  // unknownprintf("%d\n", strlen(arr2));  // 3printf("%d\n", sizeof(arr1));  // 3printf("%d\n", sizeof(arr2));  // 4return 0;
}

运行：
15
3
3
4

1.3 sizeof和strlen的对比

sizeof	strlen
1、sizeof是操作符。 2、sizeof计算操作数所占内存的大小，单位是字节。 3、不关注内存中存放什么数据。	1、strlen是库函数，使用需要包含头文件string.h 2、strlen是求字符串长度的，统计的是\0之前字符的隔个数。 3、关注内存中是否有\0，如果没有\0，就会持续往后找，可能会越界。

2、数组和指针笔试题解析

2.1 一维数组

做题之前，先理解概念：

• 1、 数组名的理解：数组名是数组首元素（第一个元素的地址）
• 2、 但有两个例外：
  • sizeof(数组名) - 数组名表示整个数组，计算的是整个数组的大小，单位是字节。
  • &数组名 - 数组名表示整个数组，取出的是整个数组的地址。
• 3、 除此之外，所有的数组名是数组首元素的地址。

#include <stdio.h>int main()
{int a[] = { 1,2,3,4 };printf("01:%zd\n", sizeof(a));          printf("02:%zd\n", sizeof(a + 0));      printf("03:%zd\n", sizeof(*a));         printf("04:%zd\n", sizeof(a + 1));     printf("05:%zd\n", sizeof(a[1]));       printf("06:%zd\n", sizeof(&a));         printf("07:%zd\n", sizeof(*&a));        printf("08:%zd\n", sizeof(&a + 1));               printf("09:%zd\n", sizeof(&a[0]));      printf("10:%zd\n", sizeof(&a[0] + 1));  return 0;
}

运行（32位环境）：
01:16
02:4
03:4
04:4
05:4
06:4
07:16
08:4
09:4
10:4

运行（64位环境）：
01:16
02:8
03:4
04:8
05:4
06:8
07:16
08:8
09:8
10:8

解析：

解析：
//01 : 16     because：sizeof(数组名)->求数组的大小。
//02 : 4/8    because：不是单独数组名，所以a是首元素的地址，类型为int*，a+0还是首元素地址。
//03 : 4      because：*a == *(a + 0) == a[0]，a是首元素的地址，*a就是首元素。
//04 : 4/8    because：a是首元素的地址，a+1跳过1个整型，a+1就是第二个元素的地址。
//05 : 4      because：a[1]就是第二个元素。
//06 : 4/8    because：&a是数组的地址，所以是4/8。再次总结，sizeof(数组名)是数组的大小，sizeof(&数组名)是数组的地址。
//07 : 16     because：*&相互抵消，所以等价于sizeof(a)。
//08 : 4/8    because：&a+1是跳过整个数组后的那个位置的地址。
//09 : 4/8    because：首元素的地址。
//10 : 4/8    because：数组第二个元素的地址。

2.2 字符数组

2.2.1 代码1

#include <stdio.h>int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("01：%zd\n", sizeof(arr));printf("02：%zd\n", sizeof(arr + 0));printf("03：%zd\n", sizeof(*arr));printf("04：%zd\n", sizeof(arr[1]));printf("05：%zd\n", sizeof(&arr));printf("06：%zd\n", sizeof(&arr + 1));printf("07：%zd\n", sizeof(&arr[0] + 1));return 0;
}

运行（32位）：
01：6
02：4
03：1
04：1
05：4
06：4
07：4

运行（64位）：
01：6
02：8
03：1
04：1
05：8
06：8
07：8

解析：

解析：
//01：6     because：数组名单独放在sizeof内部，计算的是数组的大小。  
//02：4/8   because：arr是数组名表示首元素的地址，arr+0还是首元素的地址。
//03：1     because：arr是首元素的地址，*arr就是首元素。
//04：1     because：arr[1]就是第二个元素。
//05：4/8   because：&arr是数组地址。
//06：4/8   because：跳过整个数组，指向了数组后边的空间。
//07：4/8   because：第二个元素的地址。

2.2.2 代码2

#include <stdio.h>int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("01：%zd\n", strlen(arr));printf("02：%zd\n", strlen(arr + 0));//printf("03：%zd\n", strlen(*arr));//printf("04：%zd\n", strlen(arr[1]));printf("05：%zd\n", strlen(&arr));printf("06：%zd\n", strlen(&arr + 1));printf("07：%zd\n", strlen(&arr[0] + 1));return 0;
}

运行：
01：42
02：42
05：42
06：36
07：41

解析：

解析：
//01：unknown because：arr   是首元素的地址，数组中没有\0，结果随机。
//02：unknown because：arr+0 是首元素的地址，数组中没有\0，结果随机。
//03：err     because：arr是首元素的地址，*arr是首元素，就是'a','a'的ascii码值是97
// 相当于把97作为地址传递给了strlen，strlen得到的就是野指针，代码有问题。
//04：err     because：arr[1]->'b'->98，传递给strlen也是错误的。
//05：unknown because：&arr是数组的地址，起始位置是数组的第一个元素的位置，结果随机。
//06：unknown because：随机值 x-6
//07：unknown because：随机值 x-1

2.2.3 代码3

#include <stdio.h>int main()
{char arr[] = "abcdef";printf("01：%zd\n", sizeof(arr));printf("02：%zd\n", sizeof(arr + 0));printf("03：%zd\n", sizeof(*arr));printf("04：%zd\n", sizeof(arr[1]));printf("05：%zd\n", sizeof(&arr));printf("06：%zd\n", sizeof(&arr + 1));printf("07：%zd\n", sizeof(&arr[0] + 1));return 0;
}

运行（32位）：
01：7
02：4
03：1
04：1
05：4
06：4
07：4

运行（64位）：
01：7
02：8
03：1
04：1
05：8
06：8
07：8

解析：

解析：
//01：7     because：数组总大小，7个字节。
//02：4/8   because：首元素地址。
//03：1     because：首元素。
//04：1     because：第二个元素。
//05：4/8   because：数组地址。
//06：4/8   because：跳过整个数组的地址。
//07：4/8   because：第二个元素的地址。

2.2.4 代码4

#include <stdio.h>int main()
{char arr[] = "abcdef";printf("01：%zd\n", strlen(arr));printf("02：%zd\n", strlen(arr + 0));//printf("03：%zd\n", strlen(*arr));//printf("04：%zd\n", strlen(arr[1]));printf("05：%zd\n", strlen(&arr));printf("06：%zd\n", strlen(&arr + 1));printf("07：%zd\n", strlen(&arr[0] + 1));return 0;
}

运行：
01：6
02：6
05：6
06：26
07：5

解析：

解析：
//01：6        because：6
//02：6        because：arr首元素的地址，arr+0还是首元素的地址。
//03：err      because：'a' ->97,err
//04：err      because：'b' ->98,err
//05：6        because：数组地址。
//06：unknown  because：跳过整个数组的地址。
//07：5        because：5

2.2.5 代码5

#include <stdio.h>int main()
{char* p = "abcdef";printf("01：%zd\n", sizeof(p));printf("02：%zd\n", sizeof(p + 1));printf("03：%zd\n", sizeof(*p));printf("04：%zd\n", sizeof(p[0]));printf("05：%zd\n", sizeof(&p));printf("06：%zd\n", sizeof(&p + 1));printf("07：%zd\n", sizeof(&p[0] + 1));return 0;
}

运行（32位）：
01：4
02：4
03：1
04：1
05：4
06：4
07：4

运行（64位）：
01：8
02：8
03：1
04：1
05：8
06：8
07：8

解析：

解析：
//01：4/8      because：p是指针变量，计算指针变量的大小。
//02：4/8      because：b的地址。
//03：1        because：*p是char类型，1个字节。
//04：1        because：p[0] -> *(p+0) -> *p -> 'a' 大小1个字节。
//05：4/8      because：取出的是p的地址。
//06：4/8      because：跳过p指针变量后的地址。
//07：4/8      because：取出字符串首字符的地址，+1是第二个字符的地址。

2.2.6 代码6

#include <stdio.h>int main()
{char* p = "abcdef";printf("01：%zd\n", strlen(p));printf("02：%zd\n", strlen(p + 1));//printf("03：%zd\n", strlen(*p));//printf("04：%zd\n", strlen(p[0]));printf("05：%zd\n", strlen(&p));printf("06：%zd\n", strlen(&p + 1));printf("07：%zd\n", strlen(&p[0] + 1));return 0;
}

运行：
01：6
02：5
05：3
06：11
07：5

解析：

解析：
//01：6       because：传入首元素的地址。
//02：5       because：传入第二个元素的地址。
//03：err     because：'a' -> 97,err
//04：err     because：'a' -> 97,err
//05：unknown because：&p是指针变量p的地址，和字符串"abcdef"关系不大
// 从p这个指针变量的起始位置开始向后数的，p变量存放的地址是什么，不知道，因此随机值。
//06：unknown because：随机值
//07：5       because：第二个字符的地址。

2.3 二维数组

#include <stdio.h>int main()
{int a[3][4] = { 0 };printf("01：%zd\n", sizeof(a));printf("02：%zd\n", sizeof(a[0][0]));printf("03：%zd\n", sizeof(a[0]));printf("04：%zd\n", sizeof(a[0] + 1));printf("05：%zd\n", sizeof(*(a[0] + 1)));printf("06：%zd\n", sizeof(a + 1));printf("07：%zd\n", sizeof(*(a + 1)));printf("08：%zd\n", sizeof(&a[0] + 1));printf("09：%zd\n", sizeof(*(&a[0] + 1)));printf("10：%zd\n", sizeof(*a));printf("11：%zd\n", sizeof(a[3]));return 0;
}

运行（32位）：
01：48
02：4
03：16
04：4
05：4
06：4
07：16
08：4
09：16
10：16
11：16

运行（64位）：
01：48
02：4
03：16
04：8
05：4
06：8
07：16
08：8
09：16
10：16
11：16

解析：

解析:
//01：48       because：数组的大小，48 = 3*4*sizeof(int)
//02：4        because：第一行第一个元素。
//03：16       because：第一行的数组名，单独放在sizeof内部了。
//04：4/8      because：a[0]第一行的数组名，但是a[0]并没有单独放在sizeof内部，
// 所以这里的数组名a[0]是数组首元素的地址，+1就是a[0][1]的地址。
//05：4        because：第一行第二个元素。
//06：4/8      because：a作为数组名并没有单独放在sizeof内部，a表示数组首元素的地址，
// 是二维数组首元素的地址，也就是第一行的地址，a+1跳过一行，指向第二行。
//07：16       because：a+1是第二行的地址，*(a+1)就是第二行，计算的是第二行的大小。
// *(a+1) == a[1]，a[1]是第二行数组名。
//08：4/8      because：a[0]是第一行的数组名，&a[0]取出的是数组的地址，&a[0]+1就是第二行的地址。
//09：16       because：对第二行的地址解引用。
//10：16       because：a作为数组名并没有单独放在sizeof内部，所以a表示数组首元素的地址，是
// 二维数组首元素的地址，也就是第一行的地址，*a就是第一行，计算的是第一行的大小。
// *a == *(a+0) == a[0]
//11：16       because：a[3]无需真实存在，可以通过类型推断算出长度。a[3]是第四行的数组名。

3、指针运算笔试题解析

3.1 题目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

画图解析:

3.2 题目2

//在X86环境下  
//假设结构体的大小是20个字节  
//程序输出的结构是啥?  
#include<stdio.h>
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;
}

运行：
00100014
00100001
00100004

解析：

1、struct Test* p = (struct Test*)0x100000; // 将指针p强制指向内存地址 0x100000。

2、printf("%p\n", p + 0x1);

• 当对指针进行加法（如p+0x1）时，实际地址的偏移量 = 指针指向类型的大小 * 加数。
• p是struct Test*类型，0x100000 + 0x1 * 20 = 0x100000+0x14 = 0x100014。

3、printf("%p\n", (unsigned long)p + 0x1);

• p被强制转化为unsigned long，此时是普通整数加法。

4、printf("%p\n", (unsigned int*)p + 0x1);

• p被强制转化为unsigned int*，指针运算的单位是unsigned int的大小。

3.3 题目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

解析：

int* p = a[0];        // p 指向第一行首地址（即 &a[0][0]）
printf("%d", p[0]);   // 访问 p[0] = a[0][0]

3.4 题目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;
}

运行：
FFFFFFFC,-4

解析：

• a[4][2]是第四行第2列的元素：

地址 = a基址 + 4行偏移 + 2列偏移  = a + (4×5 + 2)×4 = a + 88 字节

• p[4][2]是第4个int[4]数组的第2个元素：

地址 = p基址 + 4个数组偏移 + 2列偏移  = a + (4×4 + 2)×4  = a + 72 字节

• 地址差

&p[4][2] - &a[4][2] = (a + 72) - (a + 88) = -16 字节

• 以int为单位的：

-16 字节 / sizeof(int) = -4

输出解释：

• 在%p格式中，-4的补码表示为0xFFFFFFFC（32位系统）。

3.5 题目5

#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;
}

运行：
10,5

3.6 题目6

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

运行：
at

3.7 题目7

#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;
}

运行：
POINT
ER
ST
EW

---

完。