C语言 - 指针题目解析

ImpEvday_Wang

已于 2022-10-15 13:58:49 修改

阅读量2k

点赞数 1

CC 4.0 BY-SA版权

文章标签： c语言 c++

于 2022-08-31 09:48:23 首次发布

本文链接：https://blog.csdn.net/Hhhh_Jy/article/details/126493627

本文深入解析了C语言中一维数组、字符数组、二维数组等的使用方法及特性，通过具体示例详细说明了数组与指针的关系、sizeof与strlen的区别，并探讨了不同类型数组的操作技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目1

//一维数组

int a[ ] = { 1,2,3,4 };

printf("%d\n", sizeof(a));

//sizeof(数组名)，计算的是整个数组的大小，为4×4=16

printf("%d\n", sizeof(a + 0));

//当操作数不只是数组名时，数组名代表数组首元素的地址，因此a+0同样是数组首元素的地址，地址在32位机占4个字节，在64位机占8个字节，4/8

printf("%d\n", sizeof(*a));

//a是数组首元素地址，*a是数组首元素，类型是int型，占4个字节，4

printf("%d\n", sizeof(a + 1));

//a是数组首元素地址，加1向后偏移一个int型的字节，就是数组第二个元素的地址，仍然是一个地址，因此同样占4/8个字节

printf("%d\n", sizeof(a[1]));

//a[1]也可以化为 *(a+1)，是数组第二个元素，为int型，占4个字节，4

printf("%d\n", sizeof(&a));

//&a取出的是整个数组的地址，它与数组首元素的地址是相同的，但两者意义却是不同的，但其仍为地址，同样占4/8个字节

printf("%d\n", sizeof(*&a));

//&a先取出了整个数组的地址(是int (*) [4]类型)，解引用符号访问的权限是整个数组，计算的是整个数组的大小，占16个字节

printf("%d\n", sizeof(&a + 1));

//先取出整个数组的地址，再将其加1，这里的加1其实是向后跳过了一个数组的大小，是数组尾元素的下一个地址，仍然是一个地址，占4/8个字节

printf("%d\n", sizeof(&a[0]));

//&arr[0]( 可以化为 &(*(a+0)) )，取出数组首元素的地址，占4/8个字节

printf("%d\n", sizeof(&a[0] + 1));

//&a[0]+1( 可以化为 &(*(a+0))+1)，表示数组第二个元素的地址，占4/8个字节

//字符数组

char arr[ ] = { 'a','b','c','d','e','f' };

printf("%d\n", sizeof(arr));

//sizeof(数组名)，计算整个数组的大小，为1×6=6

printf("%d\n", sizeof(arr + 0));

//arr+0是数组首元素的地址，占4/8个字节

printf("%d\n", sizeof(*arr));

//arr表示数组首元素地址，*a是数组首元素，类型是char，占1个字节，1

printf("%d\n", sizeof(arr[1]));

//arr[1]是数组第二个元素，类型是char，占1个字节，1

printf("%d\n", sizeof(&arr));

//&arr，取地址+数组名取出的是整个数组的地址，占4/8个字节

printf("%d\n", sizeof(&arr + 1));

//&arr取出整个数组的地址，加1向后跳过了一个数组的大小，是数组尾元素的下一个地址，占4/8个字节

printf("%d\n", sizeof(&arr[0] + 1));

//&arr[0]+1，&arr[0] 取出数组首元素的地址，加1向后移动一个char的字节，是数组第二个元素的地址，占4/8个字节

//strlen计算字符串长度，给定一个指针，从该地址开始查找，依次向后查找1个字节，当找到'\0'时停止

printf("%d\n", strlen(arr));

//arr是数组首元素的地址，从此地址向后找'\0'，由于数组的最后一个元素不是'\0'，因此当查找尾元素后，将继续查找，直到找到'\0'，因此结果应为随机值

printf("%d\n", strlen(arr + 0));

//arr+0仍为数组首元素的地址，如上，为随机值

printf("%d\n", strlen(*arr));

//arr是数组首元素地址，*arr是数组首元素，是一个char型元素，字符‘a'，但参数想要的是一个地址，因此'a'的ASCII码值97将会被看成是一个地址，这样进行内存访问会出错 err

printf("%d\n", strlen(arr[1]));

//arr[1]是数组第二个元素，'b' - 98，它表示的意义和*arr一样，同样会出错 err

printf("%d\n", strlen(&arr));

//&arr取出整个数组的地址，此地址和数组首元素的地址一样，但意义不同，但在这里仍然是从此地址开始向后找'\0'，因此仍为随机值

printf("%d\n", strlen(&arr + 1));

//&arr取出整个数组的地址，加1后向后跳过了一个数组的字节大小，是数组尾元素的下一个地址，从此位置向后找'\0'，在如上数组中，结果应为随机值-6

printf("%d\n", strlen(&arr[0] + 1));

//&arr[0]取出数组首元素地址，加1向后移动一个char的大小，是数组第二个元素的地址，从此位置向后找'\0'，在此数组中，结果应为随机值-1

char arr[ ] = "abcdef";

printf("%d\n", sizeof(arr));

//sizeof(数组名)，计算整个数组的大小，为1×7=7

printf("%d\n", sizeof(arr + 0));

//arr+0是数组首元素的地址，占4/8字节

printf("%d\n", sizeof(*arr));

//*arr是数组首元素，char型，占1字节

printf("%d\n", sizeof(arr[1]));

//arr[1]也是数组首元素，char型，占1字节

printf("%d\n", sizeof(&arr));

//&arr取出的是整个数组的地址，也同样是地址，占4/8个字节

printf("%d\n", sizeof(&arr + 1));

//&arr+1取出整个数组地址，加1后跳过一个数组的大小，是数组尾元素的下一个位置的地址，占4/8个字节

printf("%d\n", sizeof(&arr[0] + 1));

//&arr[0]+1，取出数组首元素地址后加1，是数组第二个元素的地址，占4/8个字节

printf("%d\n", strlen(arr));

//arr是数组首元素的地址，从此位置向后找'\0'，结果为6

printf("%d\n", strlen(arr + 0));

//arr+0同样是数组首元素的地址，结果为6

printf("%d\n", strlen(*arr));

//*arr，是数组首元素的值，为'a'，ASCII码值被看作一个地址，会出现错误 err

printf("%d\n", strlen(arr[1]));

//arr[1]是数组第二个元素，为'b'，同样会出现错误 err

printf("%d\n", strlen(&arr));

//&arr，取出整个数组地址，与数组首元素地址相同，从此位置向后找'\0'，结果为6

printf("%d\n", strlen(&arr + 1));

//&arr+1，取出整个数组地址，加1向后跳过一个数组的大小，是数组尾元素的下一个位置的地址，从此向后找'\0'，结果为随机值

printf("%d\n", strlen(&arr[0] + 1));

//&arr[0]取出数组首元素地址后加1，是数组第二个元素的地址，从此向后找'\0'，结果为5

char* p = "abcdef";

//字符指针指向常量字符串

printf("%d\n", sizeof(p));

//p是一个指针变量，占4/8个字节

printf("%d\n", sizeof(p + 1));

//p+1，p指向'a'，加1后向后移动一个char的大小，是'b'的地址，占4/8个字节

printf("%d\n", sizeof(*p));

//*p是首元素'a'，是char型，占1个字节

printf("%d\n", sizeof(p[0]));

/p[0]，同样是首元素'a'，占1个字节

printf("%d\n", sizeof(&p));

//&p，是指针变量p的地址，占4/8个字节

printf("%d\n", sizeof(&p + 1));

//&p+1是跳过p之后的地址，占4/8个字节

printf("%d\n", sizeof(&p[0] + 1));

//&p[0]取出'a'的地址，加1是后是‘b'的地址，占4/8个字节

printf("%d\n", strlen(p));

//p是'a'的地址，向后找'\0'，结果为6

printf("%d\n", strlen(p + 1));

//p+1，p指向'a'，加1后指向'b'，向后找'\0'，结果为5

printf("%d\n", strlen(*p));

//*p，*p是字符'a' - 97，err

printf("%d\n", strlen(p[0]));

//p[0]，p[0]同样代表字符'a'，err

printf("%d\n", strlen(&p));

//&p取出指针变量p的地址，从此向后找'\0'，结果是随机值

printf("%d\n", strlen(&p + 1));

//&p+1是指针变量p的下一个地址，从此向后找'\0'，结果是随机值

printf("%d\n", strlen(&p[0] + 1));

//&p[0]是‘a'的地址，加1后是'b'的地址，向后找'\0'，结果是5

//二维数组

int a[3][4] = { 0 };

printf("%d\n", sizeof(a));

//sizeof(数组名)，计算的是整个数组大小，4×3×4 = 48

printf("%d\n", sizeof(a[0][0]));

//是数组第一行第一个元素，int型，4个字节

printf("%d\n", sizeof(a[0]));

//arr[0]是第一行的数组名，sizeof(第一行数组名)，计算的是第一行的大小，4×4 = 16

printf("%d\n", sizeof(a[0] + 1));

//a[0]是第一行数组名，没有单独放在sizeof内，也没有被取地址，因此是数组首元素的地址，a[0]+1是数组第一行第二个元素的地址，占4/8个字节

printf("%d\n", sizeof(*(a[0] + 1)));

//是数组第一行第二个元素，int型，占4个字节

printf("%d\n", sizeof(a + 1));

//a是数组第一行的地址，a+1是数组第二行的地址，4/8

printf("%d\n", sizeof(*(a + 1)));

//*(a+1)是对第二行地址解引用，计算的就是数组第二行的大小，4×4 = 16

printf("%d\n", sizeof(&a[0] + 1));

//&a[0]取的是数组第一行的地址，加1就是数组第二行的地址，4/8

printf("%d\n", sizeof(*(&a[0] + 1)));

//*(&a[0] + 1)，对第二行的地址解引用，计算的是数组第二行的大小，4×4 = 16

printf("%d\n", sizeof(*a));

//a是数组第一行的地址，对它解引用是第一行，计算的是数组第一行的大小，4×4 = 16

printf("%d\n", sizeof(a[3]));

//a[3]是数组第四行，虽然整个数组只有三行，但是sizeof在计算时实际上是根据数据类型计算的，而这个数组一行的类型是int [4]，因此所占字节为4×4 = 16

注：下述题目都以32位机来进行解答

题目二

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

题目三

#include<stdio.h>
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;
}

32位机下此结构体大小为20个字节

64位机下此结构体大小为32个字节

p+0x1，此时p是struct Test*型，在32位机下，加1向后偏移20个字节，00100014；在64位机下，加1向后偏移32个字节，0000000000100020

(unsigned long)p+0x1，p被强制类型转换为无符号长整形，加1就是整型加1，32位机，00100001；64位机，0000000000100001

(unsigned int*))p+0x1，p被强制转换为unsigned int*型，加1向后偏移4个字节，32位机，00100004；64位机，0000000000100004

注：结构体大小对于不同环境下可能不同，运行结果可能出现差异

题目四

#include<stdio.h>
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

注：此代码结果在32位机可得，64位机指针变量比整型变量大，无法得到此答案

题目五

#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，3，5，0，0，0

p是数组第一行首元素的地址，p[0]可化为*(p+0)是第一行首元素，输出1

题目六

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

指针-指针 = 它们之间的元素个数，因此为 -4

以%p打印，认为内存中存放的是地址

-4的补码为 11111111 11111111 11111111 11111100

输出为 FF FF FF FC

题目七

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

题目八

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

题目九

#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.cpp最初指向数组cp首元素地址，＋+后指向数组qp第一个元素的地址，解引用后是数组cp第一个元素，此元素是char**型。存放着数组c第二个元素的地址，解引用后是数组c第二个元素，此元素是char*型，存放常量字符串"POINT"首字符地址，从此地址向后打印字符串,输出POINT
2.cpp现在指向的是数组cp第一个元素的地址，再次++指向输出cp第二个元素的地址，解引用后是数组cp第二个元素，是char**型，存放数组c第一个元素的地址，--后是数组c首元素的地址，解引用后是数组c首元素，是char*型，存放常量字符串"ENTER"首字符地址，+3向后跳过3个char字节大小，指向字符'e'，此从地址向后打印字符串，输出ER
3.cpp[-2]可以化为*(cpp-2)，cpp现在指向数组cp第二个元素的地址，-2后是数组cp首元素的地址，解引用后是数组cp首元素，存放的是数组c第三个元素的地址，解引用后是数组c的第三个元素，此元素存放常量字符串"FIRST"首字符地址，+3向后跳过3个char字节大小，指向字符's'，从此地址向后打印字符串，输出ST
4.cpp[-1][1]可以化为*(cpp[-1]-1).再化为*(*(cpp-1)-1),cpp指向数组cp第二个元素的地址，-1后指向数组cp第一个元素的地址，解引用后是数组cp第一个元素，此元素存放数组c第二个元素的地址，-1后是数组c第一个元素的地址，解引用后是数组c第一个元素，最后+1向后跳过1个char字节大小，指向'E'，从此地址向后打印字符串，输出EW