sizeof、strlen、数组名与指针

关于数组名我们可以总结以下三条规律

1. &+数组名，取出的是整个数组的地址

2. sizeof(数组名)，计算的是整个数组的大小

3. 其余出现的数组名都是代表首元素的地址

现在来看看sizeof、strlen与数组名能擦出怎么样的火花

//一维数组
int main()
{
    int a[] = { 1,2,3,4 };
    printf("%d \n", sizeof(a));//这里的a代表整个数组，sizeof计算整个数组的大小,大小为16
    printf("%d \n", sizeof(a + 0));//这里的sizeof中不仅仅放着a，所以这里的a代表首元素的地址，a+0代表首元素的地址，大小为4/8
    printf("%d \n", sizeof(*a));//这里的sizeof不仅仅放着a，所以这里的a代表首元素的地址，*a代表a[0]，大小为4
    printf("%d \n", sizeof(a + 1));//这里的sizeof不仅仅放着a，所以这里的a代表首元素的地址，a+0代表a[1]的地址,大小为4/8
    printf("%d \n", sizeof(a[1]));//a[1]代表数组中第二个元素，大小为4
    printf("%d \n", sizeof(&a));//&a代表整个数组的地址，整个数组的地址也是地址，大小为4或者8
    printf("%d \n", sizeof(*&a));//*与&互为逆运算，所以*&a等价于a，所以这里计算整个数组的大小，大小为16
    printf("%d \n", sizeof(&a + 1));//&a代表整个数组的地址，整个数组的地址+1仍是地址，大小为4/8
    printf("%d \n", sizeof(&a[0]));//&a[0]代表着第一个元素的地址，大小为4/8
    printf("%d \n", sizeof(&a[0] + 1));//&a[0]+1代表第二个元素的地址，大小为4/8
    return 0;
}

//字符数组
int main()
{
    char arr[] = { 'a','b','c','d','e','f' };
    printf("%d \n", sizeof(arr));//arr单独放在sizeof内部，代表整个数组，sizeof计算整个数组的大小，大小为6
    printf("%d \n", sizeof(arr + 0));//arr不是单独放在sizeof内部，所以这里的arr代表首元素的地址，arr+0代表首元素的地址，大小为4/8
    printf("%d \n", sizeof(*arr));//*arr代表第一个元素，因为是char类型，大小为1
    printf("%d \n", sizeof(arr[1]));//arr[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代表第二个元素的地址，大小为4/8
    return 0;
}

//字符数组
int main()
{
    char arr[] = { 'a','b','c','d','e','f' };
    printf("%d\n", strlen(arr));//arr代表首元素的地址，因为数组中没有\0，所以结果为随机值
    printf("%d\n", strlen(arr + 0));//arr+0代表首元素的地址，因为数组中没有\0，所以结果为随机值
    printf("%d\n", strlen(*arr));//*arr代表第一个元素，因为strlen接收的是地址，这里将第一个元素的值当做地址，进行了非法访问
    printf("%d\n", strlen(arr[1]));//arr[1]代表第一个元素，因为strlen接收的是地址，这里将第一个元素的值当做地址，进行了非法访问
    printf("%d\n", strlen(&arr));//&arr代表整个数组的地址，但是strlen会将该地址当做成第一个元素的地址，又因为数组中没有\0所以结果为随机值
    printf("%d\n", strlen(&arr + 1));//&arr代表整个数组的地址，&arr+1，地址跳过了整个数组，所以结果为随机值-6
    printf("%d\n", strlen(&arr[0] + 1));//&ar代表第二个元素地址，所以结果为随机值-1
}

//字符数组
int main()
{
    char arr[] = "abcdef";
    printf("%d \n", sizeof(arr));//这里的arr单独放在sizeof内部，代表整个数组，sizeof计算整个数组大小，因为"abcdef"中隐藏一个\0,所以大小为7
    printf("%d \n", sizeof(arr + 0));//arr+0代表首元素的地址，大小为4/8
    printf("%d \n", sizeof(*arr));//*arr代表第一个元素，大小为1
    printf("%d \n", sizeof(arr[1]));//arr[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代表第二个元素的地址，大小为4/8
}

//字符数组
int main()
{
    char arr[] = "abcdef";//这里的字符串隐藏\0
    printf("%d \n", strlen(arr));//arr代表首元素地址,结果为6
    printf("%d \n", strlen(arr + 0));//arr+0代表首元素地址，结果为6
    //printf("%d\n", strlen(*arr));//*arr代表第一个元素，strlen接收的是地址，所以第一个元素被当做地址，进行了非法访问
    //printf("%d\n", strlen(arr[1]));//arr[1]代表第二个元素，strlen接收的是地址，所以第二个元素被当做地址，进行了非法访问
    printf("%d \n", strlen(&arr));//&arr代表整个数组的地址，但是strlen会将该地址当做成第一个元素的地址,结果为6
    printf("%d \n", strlen(&arr + 1));//&arr代表整个数组的地址，&arr+1，地址跳过了整个数组，所以\0也被跳过，结果为随机值
    printf("%d \n", strlen(&arr[0] + 1));//&arr[0]+1代表第二个元素的地址,结果为5
    return 0;
}

//字符数组
int main()
{
    char* p = "abcdef";
    printf("%d \n", sizeof(p));//这里的p代表指向首元素的指针，大小为4/8
    printf("%d \n", sizeof(p + 1));//p+1代表第二个元素的地址，大小为4/8
    printf("%d \n", sizeof(*p));//*p代表第一个元素，大小为1
    printf("%d \n", sizeof(p[0]));//p[0]代表第一个元素，大小为1
    printf("%d \n", sizeof(&p));//&p代表p的地址，大小为4/8
    printf("%d \n", sizeof(&p + 1));//&p+1，代表p的地址加1，大小为4/8
    printf("%d \n", sizeof(&p[0] + 1));//&p[0]+1代表第二个元素的地址，大小为4/8
    return 0;
}

//字符数组
int main()
{
    char* p = "abcdef";//这里的字符串隐藏\0
    printf("%d \n", strlen(p));//p代表首元素地址，所以结果为6
    printf("%d \n", strlen(p + 1));//p+1代表第二个元素地址，所以结果为5
    printf("%d \n", strlen(*p));//*p代表第一个元素，strlen接收的是地址，所以第一个元素被当做地址，进行了非法访问
    printf("%d \n", strlen(p[0]));//p[0]代表第一个元素，strlen接收的是地址，所以第一个元素被当做地址，进行了非法访问
    printf("%d \n", strlen(&p));//&p代表p的地址，因为不知道\0在哪，结果为随机值
    printf("%d \n", strlen(&p + 1));//&p+1代表p的地址+1，因为不知道\0在哪，结果为随机值，且跟上一个的随机值没关系
    printf("%d \n", strlen(&p[0] + 1));//&p[0]+1代表第二个元素的地址，所以结果为5
    return 0;
}

//二维数组
int main()
{
    int a[3][4] = { 0 };
    printf("%d 48\n", sizeof(a));//a单独放在sizeof内部，代表整个数组，sizeof计算整个数组的大小，大小为48
    printf("%d 4\n", sizeof(a[0][0]));//a[0][0]代表第一行第一个元素，大小为4
    printf("%d 16\n", sizeof(a[0]));//a[0]代表第一行数组的数组名，数组名单独放在sizeof内部，所以sizeof计算第一行的数组大小大小为16
    printf("%d 4\n", sizeof(a[0] + 1));//a[0]并不单独放在sizeof内部，所以这里a[0]+1代表第一行第二个元素的地址，大小为4/8
    printf("%d 4\n", sizeof(*(a[0] + 1)));//a[0]+1，解引用后代表第一行第二个元素的地址，大小为4
    printf("%d 4\n", sizeof(a + 1));//a并不单独放在sizeof内部，所以这里a+1代表第二行数组的地址，大小为4/8
    printf("%d 16\n", sizeof(*(a + 1)));//a+1代表第二行数组的地址，解引用后等价于a[1]，所以大小为16
    printf("%d 4\n", sizeof(&a[0] + 1));//&a[0]+1代表第二行数组的地址,大小为4/8
    printf("%d 16\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1)等价于a[1]，大小为16
    printf("%d 16\n", sizeof(*a));//*a等价于a[1],大小为16
    printf("%d 16\n", sizeof(a[3]));//a[3]代表第四行数组的大小，大小为16，这里没有造成越界访问，因为sizeof不会进行实质操作
    return 0;
}