11. 数组

数组名：

int a; // 变量 a 为标量
int b[10]; // 当程序完成链接后，内存中数组的位置是固定的，所以数组名的值是一个指针常量

下标引用：
*(b+3) // b 的值是一个指向整型的指针，所有3这个值根据整型值的长度进行调整
array[subscript]
*(array + (subscript))

int array[10];
int *ap = array + 2;

array+2 等同于  &array[2]
*(array+2)   等同于  array[2]

ap[0] 等同于  *(ap+(0))  等同于 array[2]
c 中 [] 与  * 一样。即 c 的下标引用和间接访问表达式一样

*ap+6  等同于 array[2] + 6

*(ap+6) 等同于  array[8]

指针与下标： 下标绝不会比指针更有效率，但指针有时比下标更有效率
int array[10], a;
for (a = 0; a < 10; a += 1) {
    array[a] = 0; //array + (a+1)*4
}

int array[10],*ap;
for (ap = array; ap < array + 10; ap++) {
    *ap = 0; //每次 +4
}

指针比下标更有效率的场合：当你在数组中1次1步(或某个固定数字)的移动时，
与固定数字相乘的运算在编译时完成，所以在运行时所需的指令就少一些。

指针和数组：

声明数组时，编译器根据声明所指定的元素数量为数组保留内存空间，然后再创建数组名，
它的值是一个常量，指向这段空间的起始位置。

声明一个指针时，编译器只为指针本身保留内存空间，它不为任何整型值分配内存空间。
而且，指针变量并未被初始化为指向任何现有的内存空间。如果它是一个自动变量，它甚至根本不会被初始化。

因此，*a是合法的，*b是非法的。*b将访问内存中某个不确定的位置。另外一方面，
表达式 b++可以通过编译，但 a++却不行，因为 a 的值是一个常量。

字符数组的初始化:
char message[] = {'H','e','l','l','o'};

char message[] = "Hello"; // 字符数组
char *message2 = "Hello";//字符串常量

多维数组下标：

int matrix[1][5]

matrix // 指向第一行的指针，指向数组的指针
matrix + 1 // 指向第二行的指针，指向数组的指针

*(matrix+1) // 指向整型的指针
*(matrix+1)+5 // 指针
*(*(matrix+1)+5) // 是个值

指向数组的指针：

int vector[10], *vp = vector; // 对,vector和vp具有相同类型，都是指向整形的指针
int matrix[3][10], *mp = matrix ;//错，matrix不是指向整形的指针，而是一个指向整形数组的指针

声明一个指向整形数组的指针： 
int (*p)[10]; // 下标的优先级高于间接访问，

所以， int (*p)[10]=matrix;//使得p指向matrix的第一行

int *pi = &matrix[0][0]; //逐个调整，而不是逐行
int *pi = matrix[0]

作为函数参数的多维数组：
与一维数组相同，不同的是，多维数组的每个元素本身是另外一个数组，编译器需要知道它的维数。

一维数组：
int vector[10];
fun1(vector) {}

void func1(int *vec)；
void func1(vec[]);


多维数组：
int matrix[3][10];
func2(matrix)

void func2(int (*mat)[10]);
void func2(int mat[][10]);

指针数组：

int *api[10]

char const *keyword[] = {
    "do",
    "for",
    "if"
};