标签：
一、数组 和 指针 的微妙关系
数组 是指将固定个数、相同类型的变量排列起来的对象。
正如之前说明的那样，给指针加 N，指针前进“当前指针指向的变量类型的长度 X N”。
因此，给指向数组的某个元素的指针加 N 后，指针会指向 N 个之后的元素。
#include <stdio.h>
int main(void)
{
int array[5];
int *p;
int i;
/* 给数组 array 的各元素设定值 */
for (i = 0; i < 5; i++)
{
array[i] = i;
}
/* 输入数组各元素的值（指针版） */
for (p = &array[0]; p != &array[5]; p++)
{
printf("%d\n", *p);
}
return 0;
}
运行结果如下：
0
1
2
3
4
从第 16 行开始一个 for 循环，最初指针 p 指向 array[0]，通过 p++ 顺序地移动指针，引导指针指向 array[5]（尽管它不存在）
使用 ++运算符给指针加 1，指针前进 sizeof(int) 个字节。
此外，第 16~18 行的代码也可以换一种写法（我们可以称之为“改写版”）。
p = &array[0];
for (i = 0, i < 5; i++)
{
printf("%d\n", *(p + i));
}
这种写法，指针并没有一步步前进，而是固定的，只是在打印的时候加 i。
话说回来，你觉得这种写法容易阅读吗？
至少在我看来，无论写成 p++，还是 *(p + i)，都不容易读。还是最初的例子中 a[i] 这样的方式更容易理解。
实际上，本书主张的是“因为利用指针运算的写法不容易阅读，所以让我们 抛弃这种写法吧”。
二、表达式中，下标运算符[] 和 数组 是没有关系的
在前一小节的“改写版”例程中，像下面这样将指针指向数组的初始元素。
p = &array[0];
其实也可以写成下面这样
p = array;
对于这种写法，很多 C 语言的入门书籍是这样说明的：
在 C 中，如果在数组名后不加[]，单独地只写数组名，那么此名称就表示“指向数组初始化元素的指针”。
在这里，我可以负责地告诉你，上面的说明是错误的。
在 C 的世界里，事到如今你再去否定“数组名后不加[]，就代表指向初始元素的指针”这个“强大的”误解显得有点无奈。对于这种已经深入人心的观点，你突然放言它其实是个误解，可能很多人无法接受。下面让我们依法来证明。
将 &array[0] 改写成 array，“改写版”的程序甚至可以写成下面这样：
p = array; // 只是改写了这里，可以 ...
for (i = 0; i < 5; i++)
{
printf("%d\n", *(p + i));
}
另外，程序中 *(p + i) 也可以写成 p[i]。
p = array;
for (i = 0; i < 5; i++)
{
printf("%d\n", p[i]);
}
也就是说，*(p + i) 和 p[i] 是同样的意思。可以认为后面的写法是前面的简便写法。
在这个例子中，最初通过 p = array; 完成了向 p 的赋值，但之后 P 一直没有发生更改。所以，早知道如此，何必当初偏要多声明一个 p，还不如一开始就写成 array 呢。
for (i = 0; i < 5; i++)
{
printf("%d\n", array[i]);
}
呀，好像又回去了呢。
结论就是，
p[i] 这种写法只不过是 *(p + i) 这种写法的简便写法，除此之外，它毫无意义。array[i] 和 p[i] 有什么不一样吗？array[i] 也可以像 p[i] 一样，将 array 解读成“指向数组的初始元素的指针”。
也就是说，存在
int array[5];
这样的声明的时候，“一旦后面不追加[]，只写 array”并不代表要使 array 具有指向数组第 1 个元素的指针的含义，无论加不加 []，
在表达式中，数组名都可以被解读成指针。
顺便说一下，对于这个规则来说，有三个小的例外，我们会在第 3 章作详细说明。
你可以认为这是一个哗众取宠的异端邪说，但至少在语法上，数组 下标运算符[] 和 数组无关。
这里也是 C 的数组下标从 0 开始的理由之一。
【要点】
【非常重要！！】
在表达式中，数组可以解读成“指向它的初始元素的指针”。尽管有 3 个小例外，但是这和在后面加不加[]没有关系。
【要点】
p[i] 和 *(p + i) 的简便写法。
下标运算符[]原本只有这种用法，它 和 数组无关。
需要强调的是，认为 [] 和 数组 没有关系，这里的 [] 是指在表达式中出现的下标运算符[]。
声明中的[]，还是表达式数组的意思。也就是说，声明中的 [] 和 表达式 中的 [] 意义完全不同。表达式中的 * 和 声明中的 * 意义也是完全不同的。这些现象使得 C 语言的声明在理解上变得更加扑朔迷离...，第 3 章将会进行详细说明。
此外，如果将 a + b 改写成 b + a，表达式的意义没有发生改变，所以你可以将 *(p + i) 写成 *(i + p)。其次，因为 p[i] 是 *(p + i) 的简便写法，实际上它也可以写成 i[p]。
引用数组元素的时候，通常我们使用 array[5] 这样的写法。其实，就算你写成 5[array]，还是可以正确地引用到你想要的元素。可是，这种写法实在太另类了，它不能给我们带来任何好处。
【要点】
p[i] 可以写成 i[p]，但不推荐这样写。
三、什么是指向数组的指针
“数组”和“指针”都是派生类型。它们都是由基本类型开始重复派生生成的。
也就是说，派生出“数组”后，再派生出“指针”，就可以生成“指向数组的指针”。
一听到“指向数组的指针”，有人也许要说：
这不是很简单嘛，数组名后不加[]，不就是“指向数组的指针”吗？
的确，在表达式中，数组名可以解读成指针。但是，这不是“指向数组的指针”，而是“指向数组初始元素的指针”。
实际地声明一个“指向数组的指针”，
int (*array_p)[3]; /* array_p 是指向 int 数组（元素个数3）的指针 */
根据 ANSI C 的定义，在数组前加上＆，可以取得“指向数组的指针”。（注意：这里是“数组可以解读成指向它初始元素的指针”这个规则的一个例外（参照 3.3.3 节））。
因此，
int array[3]; int (*array_p)[3]; array_p = &array; // 数组添加 &，取得“指向数组的指针”
这样的赋值是没有问题，因为类型相同。
可是，如果进行
array_p = array;
这样的赋值，编译器就会报出警告。
“指向 int 的指针”和“指向 int 的数组（元素个数 3）的指针”是完全不同的数据类型。
但是，从地址的角度来看，array 和 &array 也许就是指向同一地址。但要说起它们的不同之处，那就是它们在做指针运算时结果不同。
在我的机器上，因为 int 类型的长度是 4 个字节，所以给“指向 int 的指针”加 1，指针前进 4 个字节。但对于“指向 int 的数组（元素个数 3）的指针”，这个指针指向的类型为“int 的数组（元素个数 3）”，当前数组的尺寸为 12 个字节（如果 int 的长度为 4 个字节），因此给这个指针加 1，指针就前进 12 个字节。
四、Ｃ语言中，不存在多维数组
在 C 语言中，可以通过下面的方式声明一个多维数组：
int hoge[3][2];
我想企图这么干的人应该很多。请大家回忆一下 C 的声明的解读方法，上面的声明应该怎样解读呢？
是“int 类型的多维数组”吗？
这是不对的。应该是“int 的数组（元素个数 2）的数组（元素个数 3）”。
也就是说，即使 C 中存在“数组的数组”，也不存在多维数组*。
* 在 C 标准中，“多维数组”这个词最初出现在脚注中，之后这个词也会不时地出现在各个角落。尽管“不存在多维数组”这个观点会让人感觉有些极端，但如果你不接受这个观点，对于C 的类型模型的理解，可能就会比较困难。
“数组”就是将一定个数的类型进行排列而得到的类型。“数组的数组”也只不过是派生源的类型恰好为数组。图 3-7 是“int 的数组（元素个数 2）的数组（元素个数 3）”。
要 点
C 语言中不存在多维数组。
看上去像多维数组， 其实是“数组的数组”。
对于下面的这个声明：
int hoge[3][2];
可以通过 hoge[i][j]的方式去访问，此时，hoge[i]是指“int 的数组（元素个数 2）的数组（元素个数 3）”中的第 i 个元素，其类型为“int 数组（元素个数 2）”。当然，因为是在表达式中，所以在此时此刻，hoge[i]也可以被解读成“指向 int 的指针”。
关于这一点，3.3.5 节中会有更详细的说明。
那么，如果将这个“伪多维数组”作为函数的参数进行传递，会发生什么呢？
试图将“int 的数组”作为参数传递给函数，其实可以直接传递“指向 int 的指针”。这是因为在表达式中，数组可以解释成指针。
因此，在将“int 的数组”作为参数传递的时候，对应的函数的原型如下：
void func(int *hoge);
在“int 的数组（元素个数 2）的数组（元素个数 3）”的情况下，假设使用同样的方式来考虑，
int 的数组（ 元素个数 2） 的数组（元素个数 3）
其中下划线部分，在表达式中可以解释成指针，所以可以向函数传递
指向 int 的数组（ 元素个数 2） 的指针
这样的参数，说白了它就是“指向数组的指针”。
也就是说，接收这个参数的函数的原型为：
void func(int (*hoge)[2]);
直到现在，有很多人将这个函数原型写成下面这样：
void func(int hoge[3][2]);
或者这样：
void func(int hoge[][2]);
其实，
void func(int (*hoge)[2]);
就是以上两种写法的语法糖，它和上面两种写法完全相同。
关于将数组作为参数进行传递这种的情况下的语法糖，在 3.5.1 节中会再一次进行说明。
标签：
原文地址：http://www.cnblogs.com/52php/p/5683328.html
