0.数组和指针并不是相同的
我们声明数组时，同时分配了一些内存空间，用于容纳数组元素，但是当我们声明一个指针时，只分配了用于容纳指针本身的内存空间。
从这个方面也可以理解sizeof后面跟数组名和指针名的不同。
什么时候数组和指针相同呢？
c语言标准对此做了如下说明
规则1.表达式中的数组名被编译器当作一个指向该数组的一个元素的指针
规则2.下标总是与指针和偏移量相同
规则3.在函数参数的声明中（形式参数),数组名被编译器当作指向该数组第一个元素的指针
1.数组名是一个常量指针，并不是一个左值
1 #include<stdio.h>
2 int main(int argc,char **argv)
3 {
4 int array[]={1,2,3,4};
5 array++;
6 return 0;
7 }
test.c|5| error: lvalue required as increment operand
数组名不是常量指针的情况只有两种，就是当数组名是sizeof和&的操作数时，前者产生整个数组的占用的字节数，后者产生一个指向数组的指针
2.下标引用和间接操作是一样的
1 #include<stdio.h>
2 int main(int argc,char **argv)
3 {
4 int array[]={1,2,3,4};
5 int *b=array+1;
6 printf("%d\n",b[1]);
7 printf("%d\n",*(b+1));
8 printf("%d\n",b[-1]);
9 printf("%d\n",b[10]);
10 printf("%d\n",1[b]);
11 return 0;
12 }
输出
3
3
1
32595
3
这个例子说明了几个很有意思的事实，b是指针，但是b还是可以使用下标操作符，c在处理下标操作符时把b[1]看成*(b+1)
这也是为什么1[b]是合法的原因，1[b]被看成了*(1+b)，在编译器看来b[1]和1[b]并没有区别
并且c语言不进行下标检查，这是基于相信coder的设计思想，并且检查下标要消耗一定的资源
3.当要传递一个数组是形参可以是两种形式
int strlen(char *string);
int strlen(char string[]);
//甚至是下面的方法都可以
int strlen(char string[100]);//里面的数字随意
void print1(int *a) { int i; for(i=0;i < SIZE;i++) printf("%d\n",a[i]); } void print2(int a[]) { int i; for(i=0;i< 5;i++) printf("%d\n",a[i]); }
这个相等行暗示指针和数组名是相等的，但千万不要被它糊弄了，这个声明确实相等，但是只存在于当前的这个上下文环境中。
3.sizeof 的不同
1 char *a = "hello";
2 char b[]= {'h','e','l','l','o'};
3 //sizeof(a)是指针占的内存地址大小，所有类型的指针的大小都一样，是系统的字长，32位系统就是4个字节，64位系统就是8个字节
4 //sizeof(b)是数组b占的字节数，这里是5个char加上一个‘\0',是6个字节
注意指针在这里的用法，只能对字符串常量采用char *a = "hello";
int *a = {1,2,3}; //error: (twice)excess element in scalar initializer, initialization makes pointer from interger without a cast
char *b = {'h','e','l','l','o'};//error:(four times)excess element in scalar initializer, initialization makes pointer from interger without a cast
char *c = 'h'; //error: initialization makes pointer form interger without a cast
char *d = "h"; //correct
char *e ="hello" //correct
4.由第三条引出了第四条
先讲一下历史
由于 char message[]={'h','e','l','l','o'};这种初始化字符数组的方式用于比较长的字符数组显得比较傻，c语言标准提出了一种快速方法用于初始化字符数组
char message[]=“hello"; 尽管它看上去有点像字符串常量，但是它并不是，它只是前例的初始化列表的一种写法。
一个字符串常量在用于初始化一个字符数组时，它是一个初始化列表，在其它任何情况下，他都是一个字符串常量
主意区分
char message1[] = "hello"; //message1是个数组，message1也是一个常量指针，不能改变message1的指向，"hello"是数组的初始化列表，可以通过下标或者间接操作来改变值
char *message2 = "hello"; //message2指向字符串常量，message2是一个变量指针，可以改变message2的指向。不能通过下标或者间接操作来改变值。如果硬要改变的话是编译通过运行出错
5.指向数组的指针
int matrix[3][10];
matrix可以看作成是一个一维数组，它包含3个元素，每个元素是包含10个整形元素的数组(这个是在人看来的，对计算机而言matrix就是个指针,计算机没有数组的概念，它只懂得指针，数组和下标提出来只不过是方便人理解，这是我到目前为止的看法）。（如同df -h)
matrix：一个常量指针，指向它的第一个元素，所以matrix是一个指向包含10个整形元素的数组的指针
matrix+1：仍然是一个指针，在matrix的地址的基础上向后移了4*10=40个字节。但是这里不是matrix[1],maxtrix[1]相当于*(matrix+1),再次强调下标和间接操作是一样的。
matrix[0]和 *matrix：maxtrix是一个指向数组的指针，那么*maxtrix就是一个数组，包含(*maxtrix)[0]到(*matrix)[9]这么10个元素，由于数组名是第一个元素的地址，所以*matrix相当于&（*matrix)[0]也就是&matrix[0][0]，这是一个指向整数的指针。
*(*(matrix+1)+1)：有了前面的基础，这个就相当简单了,matrix[1][1]。
但是很有意思的是matrix和matrix[0]的值竟然是一样的，都是&matrix[0][0]，换句话说&matrix[0]和matrix[0]是一样的（这块我暂时不能解释，以后解决了再说）
1 #include<stdio.h>
2 int main(int argc,char **argv)
3 {
4 int matrix[3][10]={
5 {1,2,3,4,5,6,7,8,9,10},
6 {10,9,8,7,6,5,4,3,2,1},
7 {5,4,3,2,1,6,7,8,9,10}
8 };
9 printf("%p\t%p\n",matrix,matrix[0]);
10 printf("%p\t%p\n",matrix+1,matrix[1]);
11 printf("%p\t%p\n",matrix+2,matrix[2]);
12 return 0;
13 }
14
15
16 //结果
17
18 0x7ffff4609f50 0x7ffff4609f50
19 0x7ffff4609f78 0x7ffff4609f78
20 0x7ffff4609fa0 0x7ffff4609fa0
我们发现下面的都比上面的多出4*10=40个字节的地址
那么指向数组的指针怎么表示呢
int (*p)[10]=maxtrix;
看一下怎么使用
int a[10];
int (*pa)[10] = &a;
由于对于数组来说&a和a的值是一样的，所以也可以写成
int(*pa)[10]=a;//但是这样写在gcc上会得到一个warning,所以还是不要这样写的好
值虽然一样但是类型不一样，这点很重要。
那么int *pa=a;和int (*pa)[10]=&a;有什么区别呢
这两个pa的值虽然是一样的，但是类型不一样，还是这句话，第一个pa指向的是一个整数，第二个pa指向的是一个数组，第一个++pa的步长是4，第二个++pa的步长是40
int a1[3]; int a2[2][3]; int (*ap)[3]; ap=&a1; ap=a2;
用法也不一样
int a[10]={1,2};
int (*pa)[10]=&a;
int *pb=a;
这个声明看起来比我们见到过的所有声明都复杂，但事实上并不是很难。你只要假定它是一个表达式，并对它求值。下标引用的优先级高于间接访问，但由于括号的存在，首先执行的还是间接访问，所以p是一个指针，那么它指向什么呢？接下来是下标引用，所以它指向的是某种类型的数组（包含10个元素），这个表达式没有更多的操作，所以p是一个指向整形数组的指针。
那么上面matrix的类型是 int (*)[10],而matrix[0]的类型是int *
这里讲一句题外话，数组不能整体赋值给另外一个数组，只能一个一个元素赋值。
6.指针数组
注意和上面的指向数组的指针区别
int *p[10]
下标引用的优先级高于间接访问，首先执行下标引用，因此p是某种类型的数组（它包含的元素数为10）。在取得一个值以后，进行了间接访问操作，这个表达式不再有其它操作，得到的是一个int型。总结一下：对数组的某个元素进行间接操作后得到了一个int型，所以p是一个数组，它包含的元素是指向整型的指针。
#include<stdio.h>
int main(void)
{
const char *keyword_table[5]={
"do",
"while",
"if",
"else",
"switch"
};
printf("%p\t%p\t%p\t%p\t%p\t%p\t%p\t%c\n",&keyword_table,keyword_table,&keyword_table[0],&"do","do",keyword_table[0],&keyword_table[0][0],*keyword_table[0]);
return 0;
}
