指针和数组面试题（逐题分析,完善你可能遗漏的知识）

人生不是一种享乐，而是一桩十分沉重的工作。 —— 列夫·托尔斯泰

前言：之前我们就学习了数组和指针的知识。

数组：数组就是能够存放一组相同类型的元素，数组的大小取决于数组的元素个数和元素类型。

指针：指针就是存放地址的变量，称为指针变量。大小是4/8个字节(32位平台/64位平台)。

而数组和指针有什么联系呢？

数组名是首元素的地址，而地址存放在指针变量中，我们就可以使用指针变量来遍历数组。

而数组名是首元素的地址有两个特例：

1.如果数组名放在sizeof内部，也就是sizeof(数组名)，这里的数组名表示整个数组，sizeof求的也就是整个数组的字节大小。

2.&数组名，取出的是整个数组的地址。

这里我们所用的是32位的平台，所以指针的大小都是4个字节。

接下来的题我们会用到sizeof操作符和strlen函数。

细节：

1.sizeof计算的是占用内存空间的大小，单位是字节，不关注内存中到存放的是什么。

2.sizeof不是函数，是操作符。

3.strlen是函数，所用的头文件是#include<string.h>。

4.strlen是针对字符串的，求的是字符串长度，本质上统计的是/0之前出现的字符的个数。

5.strlen的参数是char*类型的，即指针。

第一类题：

int main()
{
    int a[] = { 1,2,3,4 };//数组的大小是4
    printf("%d\n", sizeof(a));//16个字节
    //a单独放在sizeof内部,表示整个数组,所以sizeof求的整个数组大小16字节

    printf("%d\n", sizeof(a + 0));//4个字节
    //a没有单独放在sizeof内部，也没有&,所以数组名表示数组首元素的地址
    //加0也是首元素的地址，也就是指针，大小是4

    printf("%d\n", sizeof(*a));//4个字节
    //a表示首元素地址，也就是&arr[0],*a也就是a[0],第一个元素的大小

    printf("%d\n", sizeof(a + 1));//4个字节
    //a表示首元素的地址,a+1表示第二个的地址，即指针大小

    printf("%d\n", sizeof(&a));//4个字节
    //&a表示取出整个数组的地址，但是还是地址，即指针的大小

    printf("%d\n", sizeof(*&a));//16个字节
    //*和&相当于抵消了,也就是表示sizeof(a),代表整个数组的大小

    printf("%d\n", sizeof(&a + 1));//4个字节
    //&a表示取出整个数组的地址,&a+1,跳过整个数组，但是还是地址，即指针的大小

    printf("%d\n", sizeof(&a[0]));//4个字节
    //取出第一个元素的地址,即指针的大小

    printf("%d\n", sizeof(&a[0] + 1));//4个字节
    //第二个元素的地址，即指针的大小
    return 0;
}

第二类题：

int main()
{
    char arr[] = { 'a','b','c','d','e','f' };
    printf("%d\n",sizeof(arr));//6个字节
    //arr单独放在sizeof内部，表示整个数组的大小

    printf("%d\n",sizeof(arr+0));//4个字节
    //arr表示数组首元素的地址,arr+0也是首元素地址，即指针大小

    printf("%d\n",sizeof(*arr));//1个字节
    //arr表示数组首元素的地址,&arr即arr[0]

    printf("%d\n",sizeof(arr[1]));//1个字节
    //表示第二个元素b

    printf("%d\n",sizeof(&arr));//4个字节
    //&arr取出的是整个数组地址

    printf("%d\n",sizeof(&arr+1));//4个字节
    //&arr取出整个数组地址,&arr+1,跳过整个数组，但还是地址，即指针的大小

    printf("%d\n",sizeof(&arr[0]+1));//4个字节
    //&arr[0]取出的是第一个数的地址,&arr[0]+1即第二个数的地址，即指针
    return 0;
}

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[]= { 'a','b','c','d','e','f' };
    printf("%d\n",strlen(arr));//随机值
    //arr表示首元素的地址,strlen求得是首元素地址后面的字符个数
    //但是字符串没有\0存在，所以大小是随机值

    printf("%d\n",strlen(arr+0));//随机值
    //一样的是首元素的地址，求出的是随机值

    printf("%d\n",strlen(*arr));//error
    //*arr表示arr[0]，即代表字符a,不是地址,代码错误

    printf("%d\n",strlen(arr[1]));//error
    //一样的不是地址，代码错误

    printf("%d\n",strlen(&arr));//随机值
    //&arr取出整个数组的地址,但是遇不到\0,大小是随机值

    printf("%d\n",strlen(&arr+1));//随机值-6
    //&arr+1跳过整个数组,得到的值是上面随机值-6

    printf("%d\n",strlen(&arr[0]+1));//随机值-1
    //&arr[0]+1代表第二个元素得地址，得到的值是上面随机值-1
    return 0;
}

    printf("%d\n",strlen(*arr));//error
    //*arr表示arr[0]，即代表字符a,不是地址,代码错误

    printf("%d\n",strlen(arr[1]));//error
    //一样的不是地址，代码错误

出现这两种，strlen里面不是地址，编译器编译就会出现下面一样的错误：

第三类题：

int main()
{
	char arr[] = "abcdef";
	//字符串末尾还隐藏了一个\0,所以数组大小为7

	printf("%d\n",sizeof(arr));//7个字节
	//arr单独放在sizeof内部,表示整个数组,大小为7

	printf("%d\n",sizeof(arr+0));//4个字节
	//arr表示首元素的地址,加0也是一样,即指针

	printf("%d\n",sizeof(*arr));//1个字节
	//arr表示&arr[0],*arr表示arr[0],大小是1

	printf("%d\n",sizeof(arr[1]));//1个字节
	printf("%d\n",sizeof(&arr));//4个字节
	//&arr取出整个数组的地址,但是还是地址,即指针

	printf("%d\n",sizeof(&arr+1));//4个字节
	//&arr+1跳过整个数组的地址，但还是地址,即指针

	printf("%d\n",sizeof(&arr[0]+1));//4个字节
	//表示第二个元素的地址
	return 0;
}

int main()
{
	char arr[] = "abcdef";
	printf("%d\n",strlen(arr));//大小是6
	//arr表示首元素的地址,求得是首元素到\0一共多少个字符

	printf("%d\n",strlen(arr+0));//大小是6
	printf("%d\n",strlen(*arr));//error
	//*arr表示arr[0]
	printf("%d\n",strlen(arr[1]));//error

	printf("%d\n", strlen(&arr));//大小是6
	//&arr整个数组的地址,但数值还是首元素的地址

	printf("%d\n", strlen(&arr+1));//大小是随机值
	//&arr+1表示跳过整个数组

	printf("%d\n", strlen(&arr[0]+1));//大小是5
	//表示第二个元素的地址
	return 0;
}

第四类题：

char* p = "abcdef";

不代表是，但可以理解为：

char arr[]="abcdef";

char*p=arr;

int main()
{
	char* p = "abcdef";
	//p表示首元素的地址
	//char arr[]="abcdef";
	//char* p = arr;
	printf("%d\n", sizeof(p));//4个字节
	//p是指针,大小是4

	printf("%d\n", sizeof(p+1));//4个字节 
	//p+1表示第二个元素b的地址,即指针

	printf("%d\n", sizeof(*p));//1个字节
	//p表示&arr[0],*p即arr[0],大小是1

	printf("%d\n", sizeof(p[0]));//1个字节
	//相当于arr[0],即第一元素

	printf("%d\n", sizeof(&p));//4个字节
	//&p表示取出一级指针的地址,跟字符串没关系,但是还是指针

	printf("%d\n", sizeof(&p+1));//4个字节
	//跳过一级指针p的全部地址

	printf("%d\n", sizeof(&p[0]+1));//4个字节
	//&p[0]相当于&arr[0],加1表示第二个元素的地址
	return 0;
}

int main()
{
	char* p = "abcedf";
	printf("%d\n", strlen(p));//大小是6
	//p代表首元素的地址

	printf("%d\n", strlen(p + 1));//大小是5
	//p+1代表第二个元素的地址

	printf("%d\n", strlen(*p));//error
	//p表示&arr[0],*p着代表arr[0]

	printf("%d\n", strlen(p[0]));//error
	printf("%d\n", strlen(&p));//随机值
	//取出的是p的地址,跟字符串无关

	printf("%d\n", strlen(&p + 1));//随机值

	printf("%d\n", strlen(&p[0] + 1));//大小是5
	//代表第二个元素的地址
	return 0;
}

第五类题：

二维数组：

int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48个字节
	//a单独放在sizeof内部表示整个数组的大小

	printf("%d\n", sizeof(a[0][0]));//4个字节
	//表示第一个元素的大小
	printf("%d\n", sizeof(a[0]));//16字节
	//a[0]表示第一行的数组名。单独放在sizeof内部，即第一行的大小

	printf("%d\n", sizeof(a[0]+1));//4个字节
	//a[0]表示第一行的数组名,即数组首元素的地址,a[0]+1表示第一行第二个数的地址

	printf("%d\n", sizeof(*(a[0]+1)));//4个字节
	//代表第一行第二个数

	printf("%d\n", sizeof(a+1));//4个字节
	//二维数组的数组名首元素的地址,即表示第一行的地址

	printf("%d\n", sizeof(*(a+1)));//16个字节
	//第一行的四个数的大小

	printf("%d\n", sizeof(&a[0]+1));//4个字节
	//&a[0]代表取出第一行的地址,加1即第二行的地址

	printf("%d\n", sizeof(*a));//16个字节
	//a表示第一行的地址,*a即第一行的四个数

	printf("%d\n", sizeof(a[3]));//16个字节
	//感觉a[3]已经数组越界了,但是sizeof内部的值不会进行计算
	return 0;
}

第六类题：

struct test
{
	int num;//4个字节
	char* name;//4个字节
	short date;//2个字节
	char ch[2];//2个字节
	short p[4];//8个字节
}*p=0x100000;//上面全部加起来就是20,所以这里结构体的大小就是20个字节
//这里我们假设p的地址就是0x100000
int main()
{
	printf("%p\n", p + 0x1);
	//结构体指针加1也就是跳过一个结构体,相当于加了十进制的20个字节，转换为16进制就是14
	//所以这里的地址就是0x100014,使用%p打印出来就是没有0x,前面再补两个0到8个比特位
	//结果就是00100014

	printf("%p\n", (unsigned long)p + 0x1);
	//unsigned long讲0x100000强制转换为无符号的整型为100000
	//加1也就是100001，最终结果就是00100001

	printf("%p\n", (unsigned int*)p + 0x1);
	//unsigned int*转换为无符号的指针
	//加1也就是加4,最终结果就是00100004
	return 0;
}