C语言指针：数组名在sizeof与strlen中的运算

一、sizeof与strlen的对比

1.sizeof是操作符，不是函数。sizeof计算的是变量所占内存空间的大小，单位是字节。如果操作数是类型的话，计算的就是类型所占内存的大小。

#include<stdio.h>
int main()
{
	int n = 10;
	printf("%d\n", sizeof(n));
	printf("%d\n", sizeof n);
	printf("%d\n", sizeof(int));
	return 0;
}

运行结果：由上面的代码和结果，sizeof计算的是变量的大小，括号()可以省略。sizeof中放类型时，计算的是类型的大小。
2.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[] = "def";
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	return 0;
}

运行结果：
通过监视窗口可以看到，arr1和arr2数组的区别，字符串的末尾其实隐藏着\0字符。
可以看到，arr1这个字符数组通过strlen求字符串长度得到的不是3，而是19，就是因为没有遇到 \0，我们也不知道 \0在内存的什么位置，所以一直往后找。而arr2数组，以字符串的形式初始化，字符串的末尾隐藏着 \0，所以strlen求出了字符串的长度为3。
通过sizeof求数组的大小，sizeof里面单独放数组名那求的就是数组的大小。可以看到上面求arr1数组的大小，因为是字符数组，数组里面有三个元素，每个元素大小是1个字节，所以数组的大小为3(字节)；而求arr2数组的大小时，因为字符串的末尾隐藏着\0字符，其实是有4个字符，所以arr2数组的大小为4(字节)。

所以sizeof和strlen的区别：

二、数组名在sizeof和strlen中的运算

1.关于一维数组在sizeof中的计算

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5 };
	printf("sizeof(arr)      =%d\n", sizeof(arr));
	printf("sizeof(arr + 0)  =%d\n", sizeof(arr + 0));
	printf("sizeof(*arr)     =%d\n", sizeof(*arr));
	printf("sizeof(arr+1)    =%d\n", sizeof(arr+1));
	printf("sizeof(arr[1])   =%d\n", sizeof(arr[1]));
	printf("sizeof(&arr)     =%d\n", sizeof(&arr));
	printf("sizeof(*&arr)    =%d\n", sizeof(*&arr));
	printf("sizeof(&arr+1)   =%d\n", sizeof(&arr+1));
	printf("sizeof(&arr[0])  =%d\n", sizeof(&arr[0]));
	printf("sizeof(&arr[0]+1)=%d\n", sizeof(&arr[0]+1));
	return 0;
}

运行结果：
对于上面的代码及结果我们逐一作解释：

1 sizeof(arr)

当数组名单独放在sizeof中时，计算的是整个数组的大小，单位字节。上面的数组是整型数组，共有5个元素，每个元素大小是4个字节，所以整个数组的大小是5*sizeof(int)=20。

2 sizeof(arr+0)
3 sizeof(arr+1)

这里数组名arr没有单独放在sizeof中，那数组名arr就表示数组首元素的地址，类型是int*，也就是数组中第一个元素的地址。表达式arr+0、arr+1最终得到的结果分别是第一个元素的地址和第二个元素的地址，是地址大小就为4/8个字节(看平台)。表达式是由运算符(操作符)和操作数组成的。注意：在sizeof中表达式是不会计算的，但是会判断表达式最终结果的数据类型。即使sizeof内部写有赋值表达式，也不会去实际操作，sizeof在计算时只看操作数的类型，不会访问相应的空间。

4 sizeof(*arr)
5 sizeof(arr[1])

对数组名解引用，得到的是数组的第一个元素，arr[1]是数组的第二个元素，数组为整型数组，则元素都为整型类型，所以大小都为4个字节。

6 sizeof(&arr)
7 sizeof(&arr+1)

之前学过，数组名表示数组首元素的地址，但是有两个例外：sizeof(数组名)和&数组名，而这里的&arr就表示取出整个数组的地址，类型为int(*)[5]，所以&arr为数组的地址，&arr+1表示跳过整个数组，指向数组后面的内存空间，也是地址，是地址大小就为4/8个字节(看平台)。

8 sizeof(*&arr)

这里可以这样理解，&arr表示取出整个数组的地址，再对其进行解引用，其实就找到了数组arr，所以这里求的就是整个数组的大小。也可以理解为*和&相互抵消了，然后就得到了数组名，sizeof(*&数组名) 就等价于sizeof(数组名)。

9 sizeof(&arr[0])
10 sizeof(&arr[0]+1)

&arr[0]表示取出数组中第一个元素的地址。&arr[0]+1表示跳过第一个元素，指向第二个元素，是第二个元素的地址，是地址大小就为4/8个字节(看平台)。

2.字符数组在sizeof中的计算

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e'};
	printf("sizeof(arr)      =%d\n", sizeof(arr));
	printf("sizeof(arr + 0)  =%d\n", sizeof(arr + 0));
	printf("sizeof(*arr)     =%d\n", sizeof(*arr));
	printf("sizeof(arr[1])   =%d\n", sizeof(arr[1]));
	printf("sizeof(&arr)     =%d\n", sizeof(&arr));
	printf("sizeof(&arr+1)   =%d\n", sizeof(&arr+1));
	printf("sizeof(&arr[0]+1)=%d\n", sizeof(&arr[0]+1));
	return 0;
}

运行结果：
与整型数组类似，上面字符数组中数组名arr单独放在sizeof中，求的是整个数组的大小，大小为5*sizeof(char)=5(字节)。而arr+0、&arr、&arr+1、&arr[0]+1都表示地址，是地址大小就为4/8个字节(看平台)。*arr、arr[1]是数组元素，大小是1个字节(看元素类型)。

3.字符数组在strlen中的运算

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e'};
	printf("strlen(arr)      =%d\n", strlen(arr));
	printf("strlen(arr + 0)  =%d\n", strlen(arr + 0));
	//printf("strlen(*arr)     =%d\n", strlen(*arr));
	//printf("strlen(arr[1])   =%d\n", strlen(arr[1]));
	printf("strlen(&arr)     =%d\n", strlen(&arr));
	printf("strlen(&arr+1)   =%d\n", strlen(&arr+1));
	printf("strlen(&arr[0]+1)=%d\n", strlen(&arr[0]+1));
	return 0;
}

运行结果：
需要注意strlen是一个函数，是用来求字符串长度的。在上面的代码中，有两行注释掉了，在上面讲过strlen函数的参数是一个const char*的指针，所以*arr、arr[1]是两个字符，作为参数传给strlen，其实是传递了字符的ASCII值给strlen，这里就会造成非法访问，会出现野指针，运行起来就会报错，所以注释掉了。注意：strlen统计的是\0之前的字符个数。所以在没遇到\0之前，就会一直往后找，直到找到\0为止，所以上面的运行结果就是一个随机值。

4.二维数组在sizeof中的运算

给一个二维数组初始化为0：

#include<stdio.h>
int main()
{
	int arr[3][4] = { 0 };
	printf("sizeof(arr)          =%d\n", sizeof(arr));
	printf("sizeof(arr[0][0])    =%d\n", sizeof(arr[0][0]));
	printf("sizeof(arr[0])       =%d\n", sizeof(arr[0]));
	printf("sizeof(*(arr[0]+1))  =%d\n", sizeof(*(arr[0]+1)));
	printf("sizeof(arr+1)        =%d\n", sizeof(arr+1));
	printf("sizeof(*(arr+1))     =%d\n", sizeof(*(arr+1)));
	printf("sizeof(&arr[0]+1)    =%d\n", sizeof(&arr[0]+1));
	printf("sizeof(*(&arr[0]+1)) =%d\n", sizeof(*(&arr[0]+1)));
	printf("sizeof(*arr)         =%d\n", sizeof(*arr));
	printf("sizeof(&arr)         =%d\n", sizeof(&arr));
	printf("sizeof(&arr+1)       =%d\n", sizeof(&arr+1));
	printf("sizeof(arr[3])       =%d\n", sizeof(arr[3]));
	return 0;
}

运行结果：
对于二维数组，需要深刻理解数组名，对上面的代码及结果作逐一解释：

1 sizeof(arr)

二维数组的数组名单独放在sizeof中，那求的就是整个二维数组的大小，大小就为3*4*sizeof(int)=48。

2 sizeof(arr[0][0])

arr[0][0]是二维数组的第一行第一个元素，类型是整型，所以通过sizeof求得的大小就为4。

3 sizeof(arr[0])

这里就需要理解arr[0]是什么意思，arr[0]是二维数组中第一行一维数组的数组名。是数组名，单独放在sizeof中那求的就是第一行这个一维数组的大小，第一行有4个元素，每个元素是int类型，则第一行一维数组的大小就为4*sizeof(int)=16。

4 sizeof(*(arr[0]+1))

这里数组名arr[0]没有单独放在sizeof中，那arr[0]就表示第一行这个一维数组首元素的地址，则arr[0]+1就是第一行一维数组的第二个元素的地址。那么*(arr[0]+1)就得到了第一行一维数组的第二元素，即arr[0][1]。数组为整型数组，则元素类型为int，元素大小就为4个字节。

5 sizeof(arr+1)

二维数组的数组名没有单独放在sizeof中，所以数组名arr表示数组首元素的地址，也就是第一行一维数组的地址，类型是int(*)[4]，所以arr+1表示跳过第一行的一维数组，指向第二行的一维数组，则arr+1就表示第二行的一维数组的地址，是地址大小就为4/8个字节(看平台)。

6 sizeof(*(arr+1))

arr+1即是二维数组第二行一维数组的数组名，那对其解引用*(arr+1)就找到了第二行的一维数组，则通过sizeof求得的就是这个一维数组的大小，大小为4*sizeof(int)=16。

7 sizeof(&arr[0]+1)

arr[0]表示的是第一行一维数组的数组名，则&arr[0]就表示取出第一行这个一维数组的地址，它是一个数组指针，&arr[0]+1就表示跳过第一行的一维数组，指向第二行的一维数组，所以&arr[0]+1就是第二行的一维数组的地址，是地址大小就为4/8个字节(看平台)。

8 sizeof(*(&arr[0]+1))

既然&arr[0]+1表示的是第二行一维数组的地址，对其解引用*(&arr[0]+1)就找到了第二行的一维数组，则通过sizeof求得的就是这个一维数组的大小，大小就是4*sizeof(int)=16。

9 sizeof(*arr)

二维数组的数组名没有单独放在sizeof中，则数组名就表示数组首元素的地址，也就是第一行一维数组的地址。对其进行解引用*arr，就找到了这个一维数组，通过sizeof求得的就是这个一维数组的大小，大小为4*sizeof(int)=16。

10 sizeof(&arr)
11 sizeof(&arr+1)

我们说过数组名表示数组首元素的地址，但是有两个特例：sizeof(数组名) 和 &数组名。除了这个两个特例以外，其他任何地方见到数组名，数组名都表示数组首元素的地址。所以这里&arr就表示取出这个二维数组的地址，类型为int(*)[3][4]，则&arr+1表示跳过整个二维数组，是指向二维数组后面的内存空间的指针，类型也是int(*)[3][4]的指针。所以&arr和&arr+1都是地址，是地址大小就为4/8个字节(看平台)。

12 sizeof(arr[3])

这里有人可能会认为数组越界了，因为数组的下标是从0开始的。记得上面我们说过，sizeof中的表达式是不会计算的，但是会判断表达式最终结果的数据类型，所以这里只是计算arr[3]的类型大小，并不会去访问arr[3]对应的空间。数组名单独放在了sizeof中，求的就是这个一维数组的大小，大小为4*sizeof(int)=16。(arr[3]是一个一维数组的数组名，要跟前面的arr[0]、arr[1]、arr[2]对应起来，要有同样的元素个数和元素类型。)