C语言——指针和数组练习题解析

前言：

学习了指针的初阶和进阶后，已经对指针有了一定了解。下面就需要做题目，去巩固所学的知识。
对数组名的理解：
数组名是数组首元素的地址，但是由两个例外

1. sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小。
2. &数组名，这里的数组名是整个数组，取出的是整个数组的地址。

一、一维数组

#include <stdio.h>
int main()
{
    
    
    int arr1[] = {
    
     1,2,3,4 };
    printf("%d\n", sizeof(arr1));
    //16（计算整个数组的大小）
    printf("%d\n", sizeof(arr1+0));
    //4/8（数组名arr1是首元素地址，a+0还是首元素的地址，地址的大小为4/8个字节）
    printf("%d\n", sizeof(*arr1));
    //4（*arr1是首元素，大小是4个字节）
    printf("%d\n", sizeof(arr1+1));
    //4/8（arr1是首元素的地址，arr1+1是第二个元素的地址，地址大小为4/8个字节）
    printf("%d\n", sizeof(arr1[1]));
    //4（arr1[1]是第2个元素，大小是4个字节）
    printf("%d\n", sizeof(&arr1));
    //4/8（&arr1是数组的地址，数组的地址也是地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(*&arr1));
    //16（&arr1是数组的地址，*&arr1是整个数组的元素，是16个字节）
    printf("%d\n", sizeof(&arr1+1));
    //4/8（&arr1是整个数组的地址，&arr1+1是跳过了整个数组的下一个地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&arr1[0]));
    //4/8（arr1[0]是首元素，&arr1[0]是首元素的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&arr1[0]+1));
    //4/8（&arr1[0]是首元素的地址，&arr1[0]+1是第二个元素的地址，是地址那就是4/8个字节）
    return 0;
}

二、字符数组

#include <stdio.h>
#include <string.h>
int main()
{
    
    
    char arr2[] = {
    
     'a','b','c','d','e','f' };
    printf("%d\n", sizeof(arr2));
    //6（数组名单独放在sizeof内部，这里的arr2表示整个数组，计算的是整个数组的大小，单位是字节，大小为6个字节）
    printf("%d\n", sizeof(arr2+0));
    //4/8（arr2表示数组的首元素地址，arr2+0还是数组的首元素地址，是地址就是4/8个字节）
    printf("%d\n", sizeof(*arr2));
    //1（arr2表示数组的首元素地址，*arr2表示首元素，大小为1个字节）
    printf("%d\n", sizeof(arr2[1]));
    //1（arr2[1]表示第二个元素，大小为1个字节）
    printf("%d\n", sizeof(&arr2));
    //4/8（&arr2是整个数组的地址，是地址就是4/8个字节）
    printf("%d\n", sizeof(&arr2+1));
    //4/8（&arr2是整个数组的地址，&arr2+1是跳过整个数组后的地址，是地址就是4/8个字节）
    printf("%d\n", sizeof(&arr2[0]+1));
    //4/8（&arr2[0]是数组的首元素地址，&arr2[0]+1是第二个元素的地址，是地址那就是4/8个字节）

    printf("%d\n", strlen(arr2));
    //随机值（因为字符数组中没有\0,所以求字符长度的时候，会一直往后找，产生的结果是随机值）
    printf("%d\n", strlen(arr2+0));
    //随机值（arr2+0是数组的首元素地址，是随机值）
    printf("%d\n", strlen(*arr2));
    //非法访问（arr2是数组的首元素地址，*arr2是数组首元素，就是字符‘a’也是97，strlen就从97这个地址开始访问，统计字符串长度，非法访问）
    printf("%d\n", strlen(arr2[1]));
    //非法访问（arr2[1]是第二个元素‘b’，以第二个元素的值为地址开始访问，统计字符串长度，非法访问）
    printf("%d\n", strlen(&arr2));
    //随机值（&arr2是整个数组的地址，数组的地址和数组首元素的地址，值是一样的，传递给strlen函数，从数组第一个位置开始统计字符串长度，结果是随机值）
    printf("%d\n", strlen(&arr2+1));
    //随机值（&arr2是整个数组的地址，&arr2+1跳过整个数组后的地址，然后开始统计字符串长度，结果为随机值）
    printf("%d\n", strlen(&arr2[0]+1));
    //随机值（&arr2[0]是首元素的地址，&arr2[0]+1是第二个元素的地址，从第二个元素地址开始统计字符串长度，结果为随机值）

    char arr3[] = "abcdef";
    printf("%d\n", sizeof(arr3));
    //7（计算整个数组的大小，‘\0’也统计在内，为7个字节）
    printf("%d\n", sizeof(arr3 + 0));
    //4/8（arr3为数组首元素地址，arr3 + 0也是数组首元素地址，是地址就是4/8个字节）
    printf("%d\n", sizeof(*arr3));
    //1（arr3为数组首元素地址，*arr3为数组首元素，首元素为1个字节）
    printf("%d\n", sizeof(arr3[1]));
    //1（arr3[1]为第二个元素，占1个字节）
    printf("%d\n", sizeof(&arr3));
    //4/8（&arr3为整个数组的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&arr3 + 1));
    //4/8（&arr3为整个数组的地址，&arr3 + 1跳过整个数组后的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&arr3[0] + 1));
    //4/8(&arr3[0]是首元素的地址，&arr3[0] + 1是第二个元素的地址，是地址那就是4/8个字节)

    printf("%d\n", strlen(arr3));
    //6（计算字符串的长度，为6）
    printf("%d\n", strlen(arr3 + 0));
    //6（arr3为首元素地址，arr3 + 0还是首元素地址，从首元素地址开始访问，统计字符串长度，字符串长度为6）
    printf("%d\n", strlen(*arr3));
    //非法访问（*arr3为数组首元素的值，非法访问）
    printf("%d\n", strlen(arr3[1]));
    //非法访问（arr3[1]为第二个元素'b',ASCII码值就是98，地址为98，开始统计字符串长度，非法访问）
    printf("%d\n", strlen(&arr3));
    //6（&arr3整个数组的地址，也是首元素地址，字符串长度为6）
    printf("%d\n", strlen(&arr3 + 1));
    //随机值（&arr3 + 1是跳过整个数组后的地址，然后开始访问，统计字符串长度，为随机值）
    printf("%d\n", strlen(&arr3[0] + 1));
    //5（&arr3[0] + 1是第二个元素的地址，从第二个元素开始统计字符串长度，长度为5）

    char* p = "abcdef";
    printf("%d\n", sizeof(p));
    //4/8（p是一个指针变量）
    printf("%d\n", sizeof(p+1));
    //4/8（p+1指向第二个元素的地址）
    printf("%d\n", sizeof(*p));
    //1（第一个元素，大小为1个字节）
    printf("%d\n", sizeof(p[0]));
    //1（数组法，第一个元素，大小为1个字节）
    printf("%d\n", sizeof(&p));
    //4/8（&p指向的是p的地址，类型是char**，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&p + 1));
    //4/8（&p + 1指向的是‘\0’后面的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(&p[0] + 1));
    //4/8（&p[0] + 1指向第二个元素的地址，得到的是‘b’的地址，是地址那就是4/8个字节）


    printf("%d\n", strlen(p));
    //6（p指向字符串首地址）
    printf("%d\n", strlen(p+1));
    //5（p+1指向字符串第二个元素首地址）
    printf("%d\n", strlen(*p));
    //非法访问（*p是—>‘a’，以‘a’为地址访问，统计字符串长度，非法访问）
    printf("%d\n", strlen(p[1]));
    //非法访问（p[1]为第二个元素‘b’，以‘b’为地址访问，统计字符串长度，非法访问）
    printf("%d\n", strlen(&p));
    //随机值（&p指向的是p的地址，类型是char**）
    printf("%d\n", strlen(&p + 1));
    //随机值（&p+1,指向的是字符串‘\0’后面的地址，）
    printf("%d\n", strlen(&p[0] + 1));
    //5（&p[0] + 1第二个元素的地址，从第二个元素地址统计字符串长度，长度为5）
    return 0;
}

三、二维数组

#include <stdio.h>
int main()
{
    
    
    int a[3][4] = {
    
     0 };
    printf("%d\n", sizeof(a));
    //3*4*4=48（整个数组的字节）
    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/8（a[0]作为第一行的数组名，没有单独放在sizeof内部，没有&，那么a[0]表示数组的首元素地址，也就是a[0][0]的地址，所以a[0]+1是第一行第二个元素的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(*(a[0]+1)));
    //4（计算第一行第二个元素的大小）
    printf("%d\n", sizeof(a+1));
    //4/8（a是数组首元素地址，是第一行的地址；a+1就是第二行的地址，类型是int(*)[4]）
    printf("%d\n", sizeof(*(a+1)));
    //16(*(a+1)->a[1]->sizeof(*(a+1)）->sizeof(a[1]),计算的是第二行的大小；a+1是第二行的地址，类型int（*）[4],*(a+1)访问的是第二行的数组)
    printf("%d\n", sizeof(&a[0]+1));
    //4/8（&a[0]是第一行的地址，&a[0]+1是第二行的地址，是地址那就是4/8个字节）
    printf("%d\n", sizeof(*( &a[0] + 1)));
    //16（第二行的大小）
    printf("%d\n", sizeof(*a));
    //16（a是数组首元素的地址，就是第一行的地址，*a就是第一行，*a—>*(a+0)—>a[0]）
    printf("%d\n", sizeof(a[3]));
    //16(不访问，只看类型)
    return 0;
}

表达式有两个属性：

1. 值属性：9
2. 类型属性：s=a+2——>short

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

打印：
2
4

四、指针题目

题目1：

#include <stdio.h>
int main()
{
    
    
    int a[5] = {
    
     1,2,3,4,5 };
    int* ptr = (int*)(&a + 1);
    printf("%d,%d", *(a + 1), *(ptr - 1));//打印  2,5
    return 0;
}

题目2：

#include <stdio.h>
//结构体大小为20个字节
struct test
{
    
    
    int num;
    char* pc;
    short date;
    char cha[2];
    short ba[4];
}*p;
int main()
{
    
    
    printf("%d\n", sizeof(struct test));
    printf("%p\n", p);
    printf("%p\n", p + 0x1);//p是结构体类型的指针，占20个字节，加1就是跳过一个结构体
    printf("%p\n", (unsigned long)p + 0x1);//无符号长整型是数值
    printf("%p\n", (unsigned int*)p + 0x1);//整型指针占4个字节
    return 0;
}

题目3：

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

分析：

题目4：

#include <stdio.h>
int main()
{
    
    
    int a[3][2] = {
    
     (0,1),(2,3),(4,5) };
    int* p;
    p = a[0];//没有&，也不在sizeof内部，表示第一行首地址表示&a[0][0]
    printf("%d\n", p[0]);//打印   1(p[0]->*p,*p的值是1)
    return 0;
}

题目5：

#include <stdio.h>
int main()
{
    
    
    int a[5][5];//定义一位二维数组（类型为int（*）[5])
    int(*p)[4];//定义一个数组指针(类型为int（*）[4])
    p = a;
    printf("%p,%b\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);//打印 ff ff ff fc      -4
    //-4
    //10000000 00000000 00000000 00000100原码
    //11111111 11111111 11111111 11111011反码
    //11111111 11111111 11111111 11111100补码
    //打印0xff ff ff fc
    return 0;
}

分析：

题目6：

#include <stdio.h>
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\n", *(ptr1 - 1), *(ptr2 - 1));//打印  10,5
    return 0;
}

题目7：

#include <stdio.h>
int main()
{
    
    
    char* a[] = {
    
     "work","at","alibaba"};
    char** pa = a;//a的首地址
    pa++;
    printf("%s\n", *pa);//打印at
    return 0;
}

题目8：

#include <stdio.h>
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;
}

分析：