指针和数组的关系(一维数组，二维数组，指针和数组笔试题）

前言

我们知道数组和指针关系密切，特别是数组名还有数组元素的数据类型，只要记住以下规则就比较容易解决大部分问题，但是二维数组还是要注意一些细节

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。

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

3. 除此之外所有的数组名都表示首元素的地址。

接下来我们比较详细简介一下指针和数组之间的关系

一维数组

int a[] = {1,2,3,4};

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

char arr[] = "abcdef";//[a b c d e f \0]

char* p = "abcdef";

二维数组

int a[3][4]={0};

二维数组可以看作每个元素为一维数组

a[0] a[1] a[3] 可以看作是每一行数组的数组名，它们的数据 类型是int （*）[4]

笔试题目（文末）

int main()
{
//一维数组
int arr[4]={1,2,3,4};
//sizeof(a));//规则一，a是整个数组大小，4*4=16个字节
    printf("%d\n", sizeof(a + 0));//只有括号内不是数组名a或者&a就是数组首元素地址，a+0跳过0个字节还是首元素地址，八个字节
    printf("%d\n", sizeof(*a));//括号内不是数组名或者&数组名就表示首元素地址，*a解引用就是1，四个字节
    printf("%d\n", sizeof(a+1));//括号内不是数组名或者&数组名就表示首元素地址，a+1就是第二个元素的地址，八个字节
    printf("%d\n", sizeof(a[1]));//括号内不是数组名或者&数组名就表示首元素地址，a[1]元素2，四个字节
    printf("%d\n", sizeof(&a));//整个数组的地址，地址都是八个字节
    printf("%d\n", sizeof(*&a));//1.*&a=a, a就是整个数组大小 4*4=16 个字节 
                                // 2.以类型视角看待 &a类型是int *[4]数组指针，指向是有四个元素的数组首元素地址
                                //解引用数组指针就是访问这个数组，16个字节
    
    printf("%d\n", sizeof(&a+1));//&a 是整个数组的地址，&a+1跳过16个字节，地址的大小是8个字节
    printf("%d\n", sizeof(&a[0]));//首元素的地址，8个字节
    printf("%d\n", sizeof(&a[0]+1));//&a[0]是首元素的地址，&a[0]+1,跳过四个字节也就是第二个元素的地址，八个字节
    return 0;
}

#include <string.h>
//
//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是首元素的地址，和第一个一样，也是随机值
//    //printf("%d\n", strlen(*arr));//err, arr是数组首元素的地址，*arr就是数组首元素，就是'a'-97
//    //strlen函数参数的部分需要传一个地址，当我们传递的是'a'时，'a'的ASCII码值是97，那就是将97作为地址传参
//    //strlen就会从97这个地址开始统计字符串长度，这就非法访问内存了
//    //printf("%d\n", strlen(arr[1]));//err
//    printf("%d\n", strlen(&arr));//&arr是数组的地址,数组的地址和数组首元素的地址，值是一样的，那么传递给strlen函数后，依然是从数组的第一个元素的位置开始往后统计
//
//    printf("%d\n", strlen(&arr + 1));//随机值
//    printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址。结果也是随机值
//
//
//    //printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部，这里的arr表示整个数组，计算的是整个数组的大小，单位是字节,总共6个字节
//    char [6]
//    //printf("%d\n", sizeof(arr + 0));//arr表示数组首元素的地址，arr+0还是数组首元素的地址，是地址就是4/8个字节
//    char*
//    //printf("%d\n", sizeof(*arr));//arr表示数组首元素的地址,*arr就是首元素，大小1个字节
//    char
//    //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));//第二个元素的地址，是4/8个字节
//
//    return 0;
//}
//


//int main()
//{
//    char arr[] = "abcdef";//[a b c d e f \0]
//    
//    printf("%d\n", strlen(arr));//6  arr是首元素地址，从a地址开始算到\0结束（不包括\0）
//    printf("%d\n", strlen(arr + 0));//6  arr首元素地址，arr+0=arr
//    //printf("%d\n", strlen(*arr));//err   *arr='a',a的ASCII为97，地址97不是该数组所在字符的地址，属于非法访问
//    //printf("%d\n", strlen(arr[1]));//err arr[1]==*(arr+1)的值为b,也是非法访问
//    printf("%d\n", strlen(&arr));//6  &arr的值也是首元素的地址
//    printf("%d\n", strlen(&arr + 1));//随机值，&arr的数据类型是int(*)[4],&arr+1就跳过这个数据对象大小指向\0末尾位置，strlen()函数从这个位置开始找\0，什么时候找到什么时候结束，所以是随机值
//    printf("%d\n", strlen(&arr[0] + 1));//5  &arr[0]数据类型是char*,&arr[0]+1跳过一个字节指向第二个元素b
//
//
//    //printf("%d\n", sizeof(arr));//7   数组arr单独放入sizeof()内部表示整个数组的地址
//    char [7]
//    //printf("%d\n", sizeof(arr + 0));//arr + 0是首元素的地址
//    //printf("%d\n", sizeof(*arr));//*arr其实就是首元素,1个字节
//    *arr--> *(arr+0) -- arr[0]
//    //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* p = "abcdef";
//    //         012345
//    
//    printf("%d\n", strlen(p));//6 传入首元素地址遇到'\0'停下，一共6个字符
//    printf("%d\n", strlen(p + 1));//5 传入第二个元素的地址，遇到'\0'停下，5个字符
//    //printf("%d\n", strlen(*p));//err 传入是字符a,不是这个数组相关的地址
//    //printf("%d\n", strlen(p[0]));//err p[0]=*(p+0)还是字符a,不是地址
//    printf("%d\n", strlen(&p));//随机值  这里传入是指针变量p的地址，随机值
//    printf("%d\n", strlen(&p + 1));//随机值  指针变量p的地址+1，也是随机值
//    printf("%d\n", strlen(&p[0] + 1));//第一个元素的地址，因为&p[0]类型为char*
//         &p[0]是第一个元素地址，&p[0]+1就是跳过一个字节就是第二个元素的地址，结果为5
//
//    //printf("%d\n", sizeof(p));//p是一个指针变量
//    大小就是4/8
//
//    //printf("%d\n", sizeof(p + 1));//p+1是'b'的地址，是地址大小就是4/8个字节
//    //
//    //printf("%d\n", sizeof(*p));//*p 就是'a'，就是1个字节&
//    //printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0) --> *p  1个字节
//
//    //printf("%d\n", sizeof(&p));//地址的大小是4/8
//    &p -- char**
//    //printf("%d\n", sizeof(&p + 1));//地址的大小
//    4/8
//    //printf("%d\n", sizeof(&p[0] + 1));//4/8 ， &p[0] + 1得到是'b'的地址 
//
//    return 0;
//}

//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]));//a[0]是第一行这个一维数组的数组名
//    //数组名算是单独放在sizeof内部了，计算的是整个数组的大小，大小是16个字节
//
//    printf("%d\n", sizeof(a[0] + 1));//?
//    //a[0]作为第一行的数组名，没有单独放在sizeo内部，没有&
//    //a[0]表示数组首元素的地址，也就是a[0][0]的地址
//    //所以a[0]+1是第一行第二个元素的地址，是地址就是4/8个字节
//    //
//    printf("%d\n", sizeof(*(a[0] + 1)));//4
//    //计算的是就是第一行第2个元素的大小
//
//    printf("%d\n", sizeof(a + 1));//4 / 8
//    //a是数组首元素的地址，是第一行的地址 int(*)[4]
//    //a+1 就是第二行的地址
//
//    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]是第一行的地址 int(*)[4]
//    //&a[0]+1 是第二行的地址 int(*)[4]
//
//    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
//    //a[3]--> int [4]
//    //
//    return 0;
//}

指针和数组相关的题目

（1）

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1);
printf("%d,%d", *(a + 1), *(ptr - 1));

    return 0;
}

&a数据类型是数组指针int (*)[5] ， &a+1跳过20个字节 就指向了5的下一个位置，把它转换成int* 改变了指针的加减步长

用指针int*ptr接收，*（ptr-1）就是减去一个四字节（整型指针减一就是减去四个字节）也就是指向了5的位置然后解引用就是5，*（a+1）a是首元素地址加一解引用就是2

（2） 

int main()
{
    int a = 7;
short s = 4; 
    printf("%d\n", sizeof(s = a + 2));//short 2

    printf("%d\n", s);//
    return 0;
}

程序经过编译----------l链接----------生成可执行文件---------运行（计算）-------结果

表达式有两个属性

1.值属性 s=9

2.数据类型属性 s=a+2-------(short)

为什么s不是9呢? 因为sizeof()运算符压根就不会对表达式进行计算，它在编译阶段就会判断s的数据类型为short,它只关心括号里面的最终的数据类型，而表达式计算是运行阶段的，这里的sizeof()里面的表达是不进行计算，sizeof只对数据类型进行判断

（3） 

struct Test
{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}* p = (struct Test*)0x100000;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

0x1这里是16进制，0x100000

p+0x100000 p 的指针类型是结构体类型大小为20个字节，0x100000十进制就是1，p+1就是跳过20个字节

也就是 0x100000+0x1=0x100020

(unsigned long)p p值是0x100000 强制转换成无符号整型 这时p就是数值 ，(unsigned int*)p + 0x1)就是数值加1，(unsigned long)p + 0x1=0x100001

(unsigned int*)p + 0x1 p 转换成int* 类型 这是p+1就是跳过四个字节，也就是0x100004

（4） 

int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
int* ptr2 = (int*)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);

int* ptr1 = (int*)(&a + 1);

&a+1指向的是数组元素4的下一个地址，（int*）(&a+1)转换成int *类型

ptr1[-1]=*(ptr-1) ptr1-1指向的是4 的地址，解引用就是4

int* ptr2 = (int*)((int)a + 1);

a是数组名指向的首元素地址，强转为int类型变成数值，（int）a+1就是数值加一，然后又强转成int*类型，也就是如下图，不过访问*ptr2在vs中是没权限访问这个地址

（5） 

int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int* p;
    p = a[0];
    printf("%d", p[1]);

    return 0;
}

数值中有逗号表达式，返回的逗号最右边的那个值，

int a[3][2]={1,3,5};--------->因为是个二维,数组实际存储变为 int a[3][2]={{1,3},{5,0},{0,0}};

所以p = a[0] p是第一行的数组的地址，p[1]=*(p+1)也就是第一行数组的第二个元素

（6） 

int main()
{

    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
        int* ptr1 = (int*)(&aa + 1);
//&aa是整个数组的地址,它的类型是int *[2][5]，&aa+1就是跳过整个数组一共40个字节，指向10的下一个位置地址，然后被强制转换为int*类型
        int* ptr2 = (int*)(*(aa + 1));
//aa是二维数组的首元素地址类型为int*[5]，aa+1就是跳过20个字节也就是6的地址，然后被强制转换为int*类型
        printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//ptr-1因为ptr1是整型指针，减一跳过四个字节也就是指向5的位置，ptr2同样的方式指向10的位置

    return 0;
}

 （8）

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf("%p, %d\n", 
        &p[4][2] - &a[4][2], 
        &p[4][2] - &a[4][2]);//-4
  

//指针与指针相减结果就是两指针之间的元素的个数 //10000000000000000000000000000100 -4的原码 //11111111111111111111111111111011 反码 //1111 1111 1111 1111 1111 1111 1111 1100 补码 //F F F F F F F C //0xFFFFFFFC 

（9） 

int main()
{
    char* a[] = { "work","at","alibaba" };

    char** pa = a;
    
    pa++;
    
    printf("%s\n", *pa);
    return 0;
}数组中a中的元素数据类型是char*，元素的地址类型是char**
//
//数组a中存储的是字符“work” "at""alibaba"的首元素地址。pa是二级指针存储数组的地址，pa++就是指向"at"地址

（10）

int main()
{
    char* c[] = { "ENTER","NEW","POINT","FIRST" };
char** cp[] = { c + 3,c + 2,c + 1,c };
char*** cpp = cp;

printf("%s\n", **++cpp);//cpp指向的是数组cp 的地址 ++cpp相当于cpp+=1,这时cpp指向c+2的地址,第一次解引用得到c+2的地址然后再次解引用得到POINT
    printf("%s\n", *-- * ++cpp + 3);
    printf("%s\n", *cpp[-2] + 3);
    printf("%s\n", cpp[-1][-1] + 1);

    return 0;
}

//cpp指向的是数组cp 的地址 ++cpp相当于cpp+=1,这时cpp指向c+2的地址,第一次解引用得到c+2的地址然后再次解引用得到POINT
// *-- * ++cpp + 3  根据优先级，先算加号的左边，cpp由于前面操作指向了c+2,++cpp同时cppy指向了c+1
解引用得到了c+1的地址，然后又--,地址减一得到C的地址同时cpp指向了c,c就是ENTER，c+3得到c中E的地址
//*cpp[-2] + 3，cpp[-2]可以理解为*(*(cpp-2))+3,cpp-2将得到c+3的地址，然后解引用得到ENTER首元素地址，最后 c+3得到S的地址
cpp[-1][-1] + 1   cpp[-1][-1]相当于*(*(cpp-1)-1)+1，
//cpp-1得到c+2的地址，解引用得到POINT的地址，*（cpp-1）-1 得到NEW的地址，解引用得到NEW首元素的地址，在加1得到NEW中E的地址