数组的本质分析

数组的概念

数组是相同类型的变量的有序集合

数组的大小

1. 数组在一片连续的内存空间中存储元素
2. 数组元素的个数可以显示或隐式指定

示例代码：数组的初始化

#include <stdio.h>

int main()
{
    int a[5] = {1, 2};
    int b[] = {1, 2};

    printf("a[2] = %d\n", a[2]);
    printf("a[3] = %d\n", a[3]);
    printf("a[4] = %d\n", a[4]);

    printf("sizeof(a) = %d\n", sizeof(a));
    printf("sizeof(b) = %d\n", sizeof(b));
    printf("count for a: %d\n", sizeof(a)/sizeof(int));
    printf("count for b: %d\n", sizeof(b)/sizeof(int));

    return 0;
}

输出结果：
a[2] = 0
a[3] = 0
a[4] = 0
sizeof(a) = 20
sizeof(b) = 8
count for a: 5
count for b: 2

数组地址与数组名

1. 数组名代表数组首元素的地址
2. 数组的地址需要用取地址符 & 才能得到
3. 数组首元素的地址值与数组的地址值相同
4. 数组首元素的地址与数组的地址是两个不同的概念。

示例代码:数组名与数组地址

#include <stdio.h>

int main()
{
    int a[5] = { 1，2，3，4，5 };

    int* b = a;
    int* c = &a[0];

    printf("b=%d, c=%d\n", *b,*c);

    printf("a = %p\n", a);
    printf("&a = %p\n", &a);
    printf("&a[0] = %p\n", &a[0]);

    printf("\n");

    printf("a+1 = %p\n", a+1);
    printf("&a+1 = %p\n", &a+1);
    printf("&a[0]+1 = %p\n", &a[0]+1);

    printf("\n");

    printf("a+1 = %d\n", *(a+1));
    printf("&a+1 = %d\n", *(&a+1));
    printf("&a[0]+1 = %d\n", *(&a[0]+1));

    return 0;
}

输出结果：
b=1, c=1

a = 0028FEFC
&a = 0028FEFC
&a[0] = 0028FEFC

a+1 = 0028FF00
&a+1 = 0028FF10
&a[0]+1 = 0028FF00

a+1 = 2
&a+1 = 2686736
&a[0]+1 = 2

虽然这a，&a，&a[0]地址相同，但是其意义却不相同。意义不相同会导致参与运算时结果不同！
（1） 当a+1，&a[0]+1 和 &a+1时，我们会发现 &a+1地址增加了数组的长度。

问题：如何分析这个现象呢？

1. 我们知道，数组是一段连续的内存空间
2. 数组的空间大小为sizeof（array_type）*array_size
3. 数组名a可看做指向数组第一个元素的常量指针。

这就解析了a+1指向的是第一个元素的下一个元素的地址，而&a却是整个数组后面的地址。因为数组名a包含了数组的长度信息，那么&a就是整个数组的地址。

（2） 从输出b和c的值我们可以得知：
a和&a[0]作为右值时相同，但a作为左值和&a[0]不同，a代表的是整个数组的地址。
1. 当变量作为右值时，代表的是这个变量存储空间的内容。如 b = a，a代表的是存储空间里的值，而不是a的地址。
2. 当变量作为左值时，代表的是这个变量的存储空间。如 b = a，b代表的是这个变量的存储空间，等同于&b。

这就解析了，当a和&a[0]作为右值时是相同的，而作为左值时，&a这代表了整个数组的地址，是一个常量，无法赋值。

数组和指针并不相同

指针和数组并不是相等的。为了说明这个概念，请考虑下面这两个声明：
1. int a[5];
2. int *b;

a和b能够互换使用吗？它们都具有指针值，它们都可以进行间接访问和下标引用操作。但是，它们还是存在相当大的区别的。

从内存角度来看
1. 声明一个数组时，编译器根据声明所指定的元素数量为数组保留内存空间，然后再创建数组名，它的值是一个常量，指向这段空间的起始位置。
2. 声明一个指针变量时，编译器只为指针本身保留内存空间，它并不为任何整型值分配内存空间。并且，指针变量并未被初始化为指向任何现有的内存空间。
因此，*a是完全合法的，但*b却是非法的。a++是非法的，而b++却是合法的。

示例代码：指针和数组不同

#include <stdio.h>

int main()
{
    int a[5] = {0};
    int b[2];
    int* p = NULL;
    int c = 0;

    p = a;

    printf("a = %p\n", a);
    printf("p = %p\n", p);
    printf("&p = %p\n", &p);
    printf("sizeof(a) = %d\n", sizeof(a));
    printf("sizeof(p) = %d\n", sizeof(p));

    printf("\n");

    p = b;

    printf("b = %p\n", b);
    printf("p = %p\n", p);
    printf("&p = %p\n", &p);
    printf("sizeof(b) = %d\n", sizeof(b));
    printf("sizeof(p) = %d\n", sizeof(p));

   // b = a;  //Error

    return 0;
}

输出结果：
a = 0028FF08
p = 0028FF08
&p = 0028FEFC
sizeof(a) = 20
sizeof(p) = 4

b = 0028FF00
p = 0028FF00
&p = 0028FEFC
sizeof(a) = 8
sizeof(p) = 4