在讲解之前我们先回顾一下，以下将要涉及的重要知识点：

1、数组名是什么？

①sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节；

②&数组名，这里的数组名表示整个数组，取出的是整个数组的地址；

③除此之外，所有的数组名都是数组首元素的地址。

2、sizeof

①sizeof是关键字(如变量名不能和关键字一样)也是操作符(功能:计算操作数的类型长度)；

②sizeof的特点：sizeof内部的表达式是不计算的；

③sizeof不是函数，因为函数调用的时候，要写括号，但是sizeof后边的括号可以省略(注:变量名可以，类型不可以)。

④sizeof的计算结果是无符号的整形unsigned int。

3、strlen

①strlen是C语言提供的库函数，可以计算字符串的长度，统计的是'\0'之前的字符个数。

②函数原型：size_t  strlen(const  char *str)，从中我们可知strlen的参数是一个地址，返回类型是无符号的整形。

总结：

①除了两种特殊情况数组名单独放在sizeof()里和&数组名，其他情况数组名都表示数组的首元素地址。

②sizeof作为操作符：计算的是操作数的类型长度，sizeof内部的表达式是不计算的。

③strlen的形参是一个地址，所以实参也要是地址。

接下来我们开始练习：

---

一维数组

分析代码运行后的结果：

1、整形数组

（1）sizeof——计算的是操作数的类型大小，单位字节

#include<stdio.h>int main()
{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));return 0;
}

答案分析：

#include<stdio.h>int main()
{int a[] = { 1,2,3,4 };printf("%d\n", sizeof(a));//16字节，单独的数组名，计算的是整个数组的大小printf("%d\n", sizeof(a + 0));//4/8字节，不是单独的数组名，a+0是首元素的地址printf("%d\n", sizeof(*a));//4字节，*a相当于a[0]，计算的是首元素的大小printf("%d\n", sizeof(a + 1));//4/8字节，不是单独的数组名，a+1是第二个元素的地址printf("%d\n", sizeof(a[1]));//4字节，a[1]是第二个元素，计算的是第二个元素的大小printf("%d\n", sizeof(&a));//4/8字节，&数组名，取的是整个数组的地址，类型是数组指针int (*)[4]printf("%d\n", sizeof(*&a));//16个字节，&数组名，取出整个数组的地址，解引用得到整个数组(*&a<-->a)printf("%d\n", sizeof(&a + 1));//4/8字节,&a+1跳过整个数组，还是数组指针(不管是否越界，只操作数关注类型)printf("%d\n", sizeof(&a[0]));//4/8字节，&a[0]取的是第一个元素的地址printf("%d\n", sizeof(&a[0] + 1));//4/8字节，&a[0]+1是第二个元素的地址return 0;
}

2.字符数组

情景1：

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

（1）sizeof——计算的是操作数的类型大小

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

答案分析：

#include<stdio.h>int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("%d\n", sizeof(arr));//6字节，数组名单独放在sizeof内部，计算的是整个数组的大小printf("%d\n", sizeof(arr + 0));//4/8字节，数组名没有单独放，arr+0是数组首元素的地址printf("%d\n", sizeof(*arr));//1字节，*arr相当于arr[0]是数组首元素，计算的是首元素的大小printf("%d\n", sizeof(arr[1]));//1字节，arr[1]是第二个元素，计算的是第二个元素的大小printf("%d\n", sizeof(&arr));//4/8字节，&数组名，取出的整个数组的地址，类型是数组指针char (*)[6]printf("%d\n", sizeof(&arr + 1));//4/8字节，&arr+1，向后跳过整个数组，指向后面的空间地址，但类型不变printf("%d\n", sizeof(&arr[0] + 1));//4/8字节，&arr[0]+1是数组第二个元素的地址return 0;
}

（2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数

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

答案解析：

#include<stdio.h>
#include<string.h>int main()
{char arr[] = { 'a','b','c','d','e','f' };//没有'\0',不知道'\0'在哪printf("%d\n", strlen(arr));//随机数，传的是数组首元素地址，类型char*printf("%d\n", strlen(arr + 0));//随机数，传的是数组首元素地址，类型char*//printf("%d\n", strlen(*arr));//err,strlen('a')-->str(97),非法访问//printf("%d\n", strlen(arr[1]));//err,'b'-98,和上面代码类似，非法访问printf("%d\n", strlen(&arr));//随机值，传的是数组指针的地址，数组指针的地址也是从数组起始地址开始的，类型char (*)[6]printf("%d\n", strlen(&arr + 1));//随机值-6，&arr+1向后跳过整个数组的地址，类型char (*)[6]printf("%d\n", strlen(&arr[0] + 1));//随机值-1，&arr[0]+1是数组第二个元素的地址，类型char*return 0;
}

情景2：

例如：char arr[] = "abcdef";

（1）sizeof——计算的是操作数类型的大小

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

答案分析：

#include<stdio.h>int main()
{char arr[] = "abcdef";printf("%d\n", sizeof(arr));//7字节，数组名单独放在sizeof内部，计算的是整个数组的大小printf("%d\n", sizeof(arr + 0));//4/8字节，arr+0<-->&arr[0]是数组首元素的地址，类型是char*printf("%d\n", sizeof(*arr));//1字节，*arr<-->arr[0]是数组首元素，计算的是首元素大小printf("%d\n", sizeof(arr[1]));//1字节，arr[1]是第二个元素，计算的是第二个元素的大小printf("%d\n", sizeof(&arr));//4/8字节，&arr是取出整个数组的地址，类型数组指针char (*)[7]printf("%d\n", sizeof(&arr + 1));//4/8字节，&arr+1是跳过整个数组的地址，类型还是数组指针char (*)[7]printf("%d\n", sizeof(&arr[0] + 1));//4/8字节，&arr[0]+1是数组第二个元素的地址，类型char*return 0;
}

（2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数

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

答案解析：

#include<stdio.h>
#include<string.h>int main()
{char arr[] = "abcdef";//字符串后默认'\0'为结束标志//a b c d e f \0printf("%d\n", strlen(arr));//6字节，传的是数组首元素的地址，strlen从数组首元素地址开始统计\0之前的字符个数类型char*printf("%d\n", strlen(arr + 0));//6字节,传的是数组首元素的地址，strlen从数组首元素地址开始统计\0之前的字符个数，类型char*//printf("%d\n", strlen(*arr));//err,*arr-->a,strlen(a)-->strlen(97),传给strlen是一个非法的地址，造成非法访问//printf("%d\n", strlen(arr[1]));//err，arr[1]-->b-->98,同上，传给strlen是一个非法的地址，造成非法访问printf("%d\n", strlen(&arr));//6字节，传的是整个数组的地址，整个数组的地址也是从数组起始地址开始统计\0之前的字符个数，类型char (*)[7]printf("%d\n", strlen(&arr + 1));//随机值,&arr+1跳过整个数组的地址，类型char (*)[7]printf("%d\n", strlen(&arr[0] + 1));//5字节,传的是第二个元素的地址return 0;
}

字符指针——指向一个常量字符串的首元素地址

（1）sizeof操作符——计算操作数类型的大小

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

答案解析：

#include<stdio.h>int main()
{char* p = "abcdef";//p指针变量，指向字符串首元素的地址printf("%d\n", sizeof(p));//4/8字节，p指针变量printf("%d\n", sizeof(p + 1));//4/8字节，p+1是b的地址printf("%d\n", sizeof(*p));//1字节，*p-->a-->字符，计算的是字符的大小printf("%d\n", sizeof(p[0]));//1字节，p[0]<-->*(p+0)-->a,同上printf("%d\n", sizeof(&p));//4/8字节，&p是二级指针，指向变量p的地址printf("%d\n", sizeof(&p + 1));//4/8字节，&p+1是跳过p变量后的地址printf("%d\n", sizeof(&p[0] + 1));//4/8字节，p[0]-->a,&p[0]就是a的地址，+1就是b的地址return 0;
}

（2）strlen——注意实参是地址，计算字符串的长度，统计的是‘\0’之前的字符个数

#include<stdio.h>
#include<string.h>int main()
{char* p = "abcdef";printf("%d\n", strlen(p));printf("%d\n", strlen(p + 1));printf("%d\n", strlen(*p));printf("%d\n", strlen(p[0]));printf("%d\n", strlen(&p));printf("%d\n", strlen(&p + 1));printf("%d\n", strlen(&p[0] + 1));return 0;
}

答案解析：

#include<stdio.h>
#include<string.h>int main()
{char* p = "abcdef";//p是指针变量，指向字符串的首元素地址printf("%d\n", strlen(p));//6字节，传的是a的地址printf("%d\n", strlen(p + 1));//5字节，传的b的地址//printf("%d\n", strlen(*p));//err,*p-->a-->97,传给strlen一个非法地址，造成非法访问//printf("%d\n", strlen(p[0]));//err,同上printf("%d\n", strlen(&p));//随机值，&p拿到的是p变量的起始地址，从这开始求字符串长度不知道\0printf("%d\n", strlen(&p + 1));//随机值，&p+1是跳过p变量的地址，从这开始求字符串长度也不知道\0位置printf("%d\n", strlen(&p[0] + 1));//5字节，&p[0]+1-->是b的地址，从b开始数字符串长度return 0;
}

二维数组

深入了解二维数组：

二维数组可以看成一维数组的数组，即一行就是是一个元素。

所以二维数组的首元素地址即第一行的地址。

例如：下图

（1）sizeof操作符——计算操作数类型的大小

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

答案分析：

#include<stdio.h>int main()
{int a[3][4] = { 0 };printf("%d\n", sizeof(a));//48字节，二维数组名单独放在sizeof内部，计算的是整个数组的大小printf("%d\n", sizeof(a[0][0]));//4字节，a[0][0]是第一行第一个元素printf("%d\n", sizeof(a[0]));//16字节，a[0]是第一行的数组名，数组名单独放在sizeof内部，//计算的就是数组(第一行)的大小printf("%d\n", sizeof(a[0] + 1));//4/8字节,a[0]作为第一行的数组名，没有单独放在sizeof内部，没有取地址，//表示的就是数组的首元素地址，a[0]即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址printf("%d\n", sizeof(*(a[0] + 1)));//4字节，a[0]+1是第一行第二个元素的地址，解引用得到元素printf("%d\n", sizeof(a + 1));//4/8字节，a是二维数组的数组名，没有单独放在sizeof内部，数组名就是二维数组首元素地址，//就是第一行的地址，那a+1就是第二行的地址，类型数组指针int (*)[4]printf("%d\n", sizeof(*(a + 1)));//16字节，(a+1)是第二行的地址，解引用得到第二行printf("%d\n", sizeof(&a[0] + 1));//4/8字节，&a[0]是第一行的地址，+1是第二行的地址printf("%d\n", sizeof(*(&a[0] + 1)));//16字节，&a[0]+1是第二行的地址，解引用得到第二行，计算的就是第二行的大小printf("%d\n", sizeof(*a));//16字节，a没有单独放在sizeof内部，表示二维数组首元素的地址，就是第一行的地址，//解引用得到第一行，计算的是第一行的大小printf("%d\n", sizeof(a[3]));//16个字节，如果存在第四行，a[3]就是第四行的数组名，单独放在sizeof，计算的是第四行的大小return 0;
}

总结：

        sizeof是操作符

（1）sizeof内部的表达式是不计算的。

#include<stdio.h>int main()
{int a = 2;short s = 3;printf("%d\n", sizeof(s = a + 3));printf("%d\n", s);return 0;
}

运行结果：

tip：①sizeof在编译时就执行了，而表达式求值在运行时才执行；

        ②表达式求值的两个属性：值属性和类型属性。

（2）sizeof只关注操作数占用内存空间的大小，单位是字节，不关心内存中存放的是什么。

        strlen是库函数

（1）strlen是求字符串长度的，统计的是'\0'之前出现的字符个数，一定要找到'\0'才算结束，所以可能存在越界访问的。