C语言和指针数组有关的一些题目

一.一维数组的大小

数组名的意义：
1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
除此之外所有的数组名都表示首元素的地址。

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));

在这里我是在X64环境下运行的，所以地址的大小都是8

int main()
{
	int a[] = { 1,2,3,4 };
	//X64环境下，地址的大小是8个字节，X86环境下地址大小是4个字节
	printf("%zd\n", sizeof(a));
	//数组名在这里表示整个数组，这个数组大小为16个字节
	printf("%zd\n", sizeof(a + 0));
	//数组名不是单独放在sizeof里面，所以不代表整个数组
	//表示的是首元素地址+0的偏移量，仍是第一个元素的地址，所以大小是8个字节
	printf("%zd\n", sizeof(*a));
	//解引用首元素地址，得到的是第一个元素，其是Int型，大小是4个字节
	printf("%zd\n", sizeof(a + 1));
	//和sizeof(a + 0)一样，是第二个元素的地址，大小是8个字节
	printf("%zd\n", sizeof(a[1]));
	//计算的是第二个元素的大小，是4个字节
	printf("%zd\n", sizeof(&a));
	//&数组名，取出的是整个数组的地址，所以是8个字节
	printf("%zd\n", sizeof(*&a));
	//先取地址得到整个数组的地址，在解引用得到整个数组，所以大小是16个字节
	printf("%zd\n", sizeof(&a + 1));
	//地址 + 1，只是这里+1是跳过整个数组，仍然是个地址，所以大小还是8个字节
	printf("%zd\n", sizeof(&a[0]));
	//取出的是第一个元素的地址，地址大小是8个字节
	printf("%zd\n", sizeof(&a[0] + 1));
	//地址+1，仍然是个地址，所以大小还是8个字节
	return 0;
}

我们来看结果：

二.字符数组

2.1

strlen的用法是计算一个字符串/字符数组的长度，计算方法是从你给的地址开始，一直遇到\0，计算\0之前出现的元素个数。

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%zd\n", sizeof(arr));
	printf("%zd\n", sizeof(arr + 0));
	printf("%zd\n", sizeof(*arr));
	printf("%zd\n", sizeof(arr[1]));
	printf("%zd\n", sizeof(&arr));
	printf("%zd\n", sizeof(&arr + 1));
	printf("%zd\n", sizeof(&arr[0] + 1));
	printf("%zd\n", strlen(arr));
	printf("%zd\n", strlen(arr + 0));
	printf("%zd\n", strlen(*arr));
	printf("%zd\n", strlen(arr[1]));
	printf("%zd\n", strlen(&arr));
	printf("%zd\n", strlen(&arr + 1));
	printf("%zd\n", strlen(&arr[0] + 1));

注意这里有个代码是错误代码，不要直接放到自己的编译器去，否则会出错

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%zd\n", sizeof(arr));
	//arr单独放在sizeof里面，所以这里计算的是整个数组的大小，6个字节
	printf("%zd\n", sizeof(arr + 0));
	//首元素地址+0代表的还是首元素的地址，8个字节
	printf("%zd\n", sizeof(*arr));
	//arr先解引用，得到的是第一个元素，第一个元素的大小是1个字节
	printf("%zd\n", sizeof(arr[1]));
	//计算第二个元素的大小，是1个字节
	printf("%zd\n", sizeof(&arr));
	//取出整个数组的地址，既然是地址大小就是8个字节
	printf("%zd\n", sizeof(&arr + 1));
	//去整个数组的地址并+1，跳过一个数组，但是它还是地址，大小8个字节
	printf("%zd\n", sizeof(&arr[0] + 1));
	//第一个元素地址+1，得到第二个元素的地址，大小是8个字节
	printf("%zd\n", strlen(arr));
	//因为strlen接收的地址是首元素地址，但是数组后面没有\0，所以结果是随机值
	printf("%zd\n", strlen(arr + 0));
	//和上面一样，拿到的也是首元素地址，但是数组后面没有\0，所以结果是随机值
	
	//printf("%zd\n", strlen(*arr));
	//解引用数组首元素地址，得到的是首元素'a',而strlen会把'a'的ASCII码值当成一个地址,所以电脑会报错
	//因为这个代码是错误的代码，所以我把它注释掉，否则妨碍执行其它代码
	//printf("%zd\n", strlen(arr[1]));
	//同理这里得到的是第二个元素，同样会发生错误

	printf("%zd\n", strlen(&arr));
	//取出的是整个数组的地址，但是首元素的地址和整个数组的地址一样
	//strlen仍然计算整个数组的大小，但是没有\0所以也是随机值
	printf("%zd\n", strlen(&arr + 1));
	//此时指针指向的是字符'f'地址的后面，我们仍然不知道\0在哪，所以也是随机值
	//而且这个随机值比从首字符地址开始算的随机值少6
	printf("%zd\n", strlen(&arr[0] + 1));
	//从第二个元素开始计算，后面没有\0，所以是随机值
	//而且这个随机值比从首字符地址开始算的随机值少1

2.2

char arr[] = "abcdef";
printf("%zd\n", sizeof(arr));
printf("%zd\n", sizeof(arr+0));
printf("%zd\n", sizeof(*arr));
printf("%zd\n", sizeof(arr[1]));
printf("%zd\n", sizeof(&arr));
printf("%zd\n", sizeof(&arr+1));
printf("%zd\n", sizeof(&arr[0]+1));
printf("%zd\n", strlen(arr));
printf("%zd\n", strlen(arr+0));
printf("%zd\n", strlen(*arr));
printf("%zd\n", strlen(arr[1]));
printf("%zd\n", strlen(&arr));
printf("%zd\n", strlen(&arr+1));
printf("%zd\n", strlen(&arr[0]+1));

	char arr[] = "abcdef";
	//定义的字符数组，会自动在字符串后面加上\0
	printf("%zd\n", sizeof(arr));
	//计算整个数组的大小，6个字节，但是sizeof会把\0也算进去，所以结果是8个字节
	printf("%zd\n", sizeof(arr + 0));
	//首元素地址+0，还是首元素地址，是地址所以大小是8个字节
	printf("%zd\n", sizeof(*arr));
	//解引用首元素地址，得到的是首元素，所以首元素大小是1个字节
	printf("%zd\n", sizeof(arr[1]));
	//计算第二个元素的大小，1个字节
	printf("%zd\n", sizeof(&arr));
	//取地址arr得到的是整个数组的地址，只要是地址，大小就是8个字节
	printf("%zd\n", sizeof(&arr + 1));
	//整个数组+1，跳过一个数组，但仍然是地址，大小为8个字节
	printf("%zd\n", sizeof(&arr[0] + 1));
	//首元素地址+1，指向的是第二个元素，但仍然是地址，大小为8个字节
	printf("%zd\n", strlen(arr));
	//是从首元素地址开始算，因为字符数组自动在后面加上\0，所以结果是6
	printf("%zd\n", strlen(arr + 0));
	//首元素地址+0，仍然是首元素地址，结果也是6

	//printf("%zd\n", strlen(*arr));
	//解引用首元素地址，得到的是首元素，strlen会把'a'的ASCII码值当成地址，会发生错误
	//防止不能正常运行其他代码，将这个错误代码注释掉
	//printf("%zd\n", strlen(arr[1]));
	//同理，得到的是第二个元素

	printf("%zd\n", strlen(&arr));
	//整个数组的地址和，首元素地址一样，计算的还是6
	printf("%zd\n", strlen(&arr + 1));
	//此时指针指向的是数组\0后的地址，我们不知道后面什么时候有\0，所以是随机值
	printf("%zd\n", strlen(&arr[0] + 1));
	//从第二个元素开始计算，结果是5

2.3

	char* p = "abcdef";
	printf("%zd\n", sizeof(p));
	printf("%zd\n", sizeof(p + 1));
	printf("%zd\n", sizeof(*p));
	printf("%zd\n", sizeof(p[0]));
	printf("%zd\n", sizeof(&p));
	printf("%zd\n", sizeof(&p + 1));
	printf("%zd\n", sizeof(&p[0] + 1));
	printf("%zd\n", strlen(p));
	printf("%zd\n", strlen(p + 1));
	printf("%zd\n", strlen(*p));
	printf("%zd\n", strlen(p[0]));
	printf("%zd\n", strlen(&p));
	printf("%zd\n", strlen(&p + 1));
	printf("%zd\n", strlen(&p[0] + 1));

	char* p = "abcdef";
	//指针p存放的的是字符串首元素的地址
	printf("%zd\n", sizeof(p));
	//p是地址，大小是8个字节
	printf("%zd\n", sizeof(p + 1));
	//p是char*类型的指针，+1跳过1个字节，指向p的位置，但它还是地址，是地址大小是8个字节
	printf("%zd\n", sizeof(*p));
	//解引用p，因为p存的是a的地址，解引用找到的是a,字符a的大小是1个字节
	printf("%zd\n", sizeof(p[0]));
	//p[0] == *(p+0),找到的还是第一个元素'a',大小是1个字节
	printf("%zd\n", sizeof(&p));
	//这里取的是指针p的地址，只要是地址，大小是8个字节
	printf("%zd\n", sizeof(&p + 1));
	//因为指针p虽然存的是字符串的地址，但是它本身也是有一块自己的空间
	//&p+1得到的是，p的空间后面的那一个地址只要是地址，大小是8个字节
	printf("%zd\n", sizeof(&p[0] + 1));
	//字符'a'的地址+1，找到的是字符'b'的地址是地址，大小是8个字节
	
	printf("%zd\n", strlen(p));
	//p是字符串首元素'a'的地址，所以从a开始往后找\0,最后结果是6
	printf("%zd\n", strlen(p + 1));
	//'a'的地址+1，得到的是'b'的地址，所以大小要比上面的少一，结果是5
	
	//printf("%zd\n", strlen(*p));
	//解引用p得到的是字符'a'，系统会把'a'的ASCII码值当成地址，会报错，所以先注释掉
	//printf("%zd\n", strlen(p[0]));
	//和上面同理

	printf("%zd\n", strlen(&p));
	//&p是把指针p的地址取出来，因为p自己有一块单独的空间，和字符串所在的空间不一样
	//我们不知道p的地址后面什么时候有\0，所以结果是随机值
	printf("%zd\n", strlen(&p + 1));
	//和上面差不多，但是这里是从指针p的末尾开始找\0，虽然也是随机值，但是和上面的不一样
	printf("%zd\n", strlen(&p[0] + 1));
	//p[0] == *(p+0)
	//&p[0] == &*(p+0) == p+0 == p
	//p是'a'的地址，+1是'b'的地址，从'b'往后数，所以结果是5

我们来看结果：

三.二维数组

我们把二维数组当成一维数组，也就是说每一行都是二维数组的一个元素，这个元素的元素类型是数组，a[0][x]里面的a[0]就是二维数组的第一个元素。a[0]就是第一个元素的数组名。

int a[3][4] = {0};
printf("%zd\n",sizeof(a));
printf("%zd\n",sizeof(a[0][0]));
printf("%zd\n",sizeof(a[0]));
printf("%zd\n",sizeof(a[0]+1));
printf("%zd\n",sizeof(*(a[0]+1)));
printf("%zd\n",sizeof(a+1));
printf("%zd\n",sizeof(*(a+1)));
printf("%zd\n",sizeof(&a[0]+1));
printf("%zd\n",sizeof(*(&a[0]+1)));
printf("%zd\n",sizeof(*a));
printf("%zd\n",sizeof(a[3]));

int main()
{
	int a[3][4] = { 0 };
	printf("%zd\n", sizeof(a));
	//计算的是整个数组的大小，48个字节
	printf("%zd\n", sizeof(a[0][0]));
	//计算的是第一行的第一个元素的大小，4个字节
	printf("%zd\n", sizeof(a[0]));
	//a[0]是二维数组的第一行，相当于一维数组的数组名，计算的是第一行元素的大小，16个字节
	printf("%zd\n", sizeof(a[0] + 1));
	//这里不是数组名单独放在sizeof里面，所以a[0]在这里代表首元素地址
	//a[0]相当于二维数组的第一行，第一行的首元素地址+1，是第一行的第二个元素的地址，8个字节
	printf("%zd\n", sizeof(*(a[0] + 1)));
	//拿到的是第一行的第二个元素，大小是4个字节
	printf("%zd\n", sizeof(a + 1));
	//a代表二维数组的首元素地址，二维数组的首元素地址就是第一行元素的地址
	//第一行元素地址+1是第二行元素的地址，大小是8个字节
	printf("%zd\n", sizeof(*(a + 1)));
	//解引用拿到的是第二行的元素，大小是16个字节
	printf("%zd\n", sizeof(&a[0] + 1));
	//&a[0]取出的是整个第一行的地址，+1后得到的是整个第二行的地址，大小是8个字节
	printf("%zd\n", sizeof(*(&a[0] + 1)));
	//解引用第二行，计算的是整个第二行的大小，是16个字节
	printf("%zd\n", sizeof(*a));
	//a在这里不是单独放到sizeof里面，所以a代表的是首元素地址，也就是第一行的地址，解引用第一行拿到的是整个第一行
	//大小是16个字节
	printf("%zd\n", sizeof(a[3]));
	//数组名单独放到sizeof里，计算的是整个第4行的大小，16个字节
	return 0;
}

我们来看结果：

四.指针笔试题

4.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;
}

因为&a取出的是整个数组的地址，所以&a+1跳过的是整个数组。a是首元素地址。

a+1是跳过一个元素，因为ptr也是int*类型的，所以ptr-1也是跳过一个元素。

对两个分别解引用，得到的就是2，5.

4.2

这题我们在32位系统运行的，所以结构体大小是20字节，如果是64位，大小应该是32

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;
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

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;
	printf("%p\n", p + 0x1);
	//+0x1,就是+1
	//p是一个地址，地址+1要跳过一个p类型的大小，也就是结构体的大小20个字节
	//%p打印的是地址，是16进制。20转换成16进制是0x14
	//结果就是0x100000+0x000014 = 0x00100014(前面自动补俩0,因为32位系统，地址也是32位->8个字节)
	printf("%p\n", (unsigned long)p + 0x1);
	//这里把p转换成unsigned long类型，已经不是地址了，这里+1就是+1，不是+20
	//结果是0x00100001
	printf("%p\n", (unsigned int*)p + 0x1);
	//指针被强制类型转换成unsigned int*类型，所以+1增加4个字节
	//结果是0x00100004
	return 0;
}

我们看结果：

4.3

%p是打印地址
%x是以16进制格式打印

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+1和第一题一样，指向的是数组末尾位置
(int)a+1，a本来是个地址，强制类型转换成int类型，+1就是往后+1，假设a存的地址是0x00000015，+1后变成0x00000016,也就是加了一个字节。

ptr1[-1] == *(ptr1 - 1).也就是得到第四个元素4

*ptr2就比较麻烦了，因为ptr2是int * 类型的，解引用可以访问4个字节。我们将数组里的元素放到内存中观察(以小端字节序存储)

*ptr2访问的应该就是00 00 00 02，但是在内存中存储是这个样子的，以16进制打印出来的时候应该是2000000（2前面的零省略）。同理ptr1[-1]打印出来的4前面的0也全部省略。

只能在x86环境下测试，否则会报错

我们看结果：

4.4

这题有个易错点：我们第一眼可能会以为二维数组第一行存的是0，1第二行2，3第三行4，5。但这是错的，我们仔细看数组里其实是三个逗号表达式，也就是说他只初始化了三个数1，3，5

int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

a[0]是数组名代表首元素地址，也就是第一行第一个元素的地址。把这个地址传给p，p指向的就是第一行第一个元素。
p[0] == *(p + 0) == *p.拿到的就是第一行第一个元素->1。

我们看结果：

4.5

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

我们先看看a,p都代表什么

我们发现a，p都是数组指针，但是a的类型是int ( * )[5],p的类型是int ( * )[4]。既然类型不一样，那可以把a的地址赋值给p吗？当然可以，这是可以放的下的，只是会有警告。

因为p指向的是只有四个元素的数组

&p[4][2] == ((p+4)+2)

我们标出p[4][2]和a[4][2]的位置

两个地址相减得到的结果，是两个地址之间的元素。我们可以通过上图看出结果应该是**-4**
那-4以地址形式打印出来是怎么写呢？
原码：10000000000000000000000000000100
反码：11111111111111111111111111111011
补码：11111111111111111111111111111100
这是二进制表示，地址以十六进制表示：
FFFFFFFC（x86）
FFFFFFFFFFFFFFFC（x64）

我们看结果：

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+1)，解引用拿到的是整个第二行。又因为 * (aa+1) == aa[1]，数组名就相当于首元素地址。所以这个代码拿到的是第二行第一个元素的地址

所以ptr2-1,ptr1-1分别找到的是5，10.我们来看结果

4.7

int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

数组a里面的元素类型是char*,也就是每个元素都是上面那几个字符串的首地址。pa是char**类型的指针，是把数组的首元素地址传了过去

pa++自然而然表示的就是数组a[1]的地址。解引用拿到的就是字符串”at“的首元素地址。打印出来的就是at

4.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装的分别是c+3,c+2,c+1,c+0的地址，指针cpp装的是数组cp数组首元素的地址。

**++cpp
指针先++指向数组cp的第二个元素，解引用第一次找到的是数组c[2]的地址，再解引用，找到的是字符串"POINT".
打印的就是POINT

*-- * ++cpp + 3
此时应该注意cpp在上一行代码进行了自加操作，cpp指向的位置已经变了。
首先cpp先自加1，指向cp[2]的空间：

然后解引用得到了c+1的空间。然后在自减1,就是对空间的值减1—>c+1-1为c

在解引用得到了“ENTER”的地址，这个地址加3，得到了倒数第二个字符’E’的地址，然后在打印，得到结果ER。

*cpp[-2] + 3
cpp[-2] == *(cpp-2),也就是拿到了c[3]的空间，在解引用也就是拿到了"FIRST"的首元素地址，+3就是找到了‘S’的地址，打印出来就是ST。

cpp[-1][-1] + 1
上个代码cpp[-2],cpp指针自身没变，cpp还是指向cp[2]。
cpp[-1][-1] == * ( * (cpp-1) - 1)
cpp-1是cp[1]，在解引用找到了c+2的空间
也就是* (cpp-1) == c+2
之后在-1,c+2变成了c+1,也就是找到了c+1的空间
也就变成了*(c+1)
在解引用得到了c+1指向的内容："NEW"首元素地址
最后首元素地址在+1，得到’E’的地址
打印出来就是EW

我们来看结果：