1.基本概念
1.1 存储单元
存储单元一般应具有存储数据和读写数据的功能，以8位(bit)二进制作为一个存储单元，也就是一个字节。
每个单元有一个地址，是一个整数编码，可以表示为二进制整数。程序中的变量和主存储器的存储单元相对应。
变量的地址对应着存储单元的地址，变量内容对应着单元所存储的数据。
存储地址一般用十六进制数表示，而每一个存储器地址中又存放着一组二进制(或十六进制)表示的数，通常称为该地址的内容。
变量有三个要素是：变量名、变量类型、变量值。
变量代表了一个存储单元，其中的值是可变的，故称为变量。
1.2 C语言的变量
变量a 本质上代表一个存储单元。CPU通过该存储单元的地址访问该存储单元中的数据。所以a本来代表两个值：存储单元的地址和储单元中的数据。于是就有了二异性。
为了消除这种二义性，C语言规定a表示存储单元中的数据，&a表示存储单元的地址。
a存储单元中的数据可以是一个普通数值，也可以是另一个存储单元的地址，比如：
a = &b;
语句就是将b的存储单元的地址存入a存储单元中。
C语言规定*a代表a中存储的地址对应的存储单元中的数据，也就是访问*a就等于访问b，于是*a提供了通过a访问b中的数据的手段。
1.3 操作符 *、&
*：取某地址的值（数据内容），运算符后通常跟一个地址
&：取某数据（变量）的地址，运算符后通常跟一个变量
- a表示a对应的存储单元中的数据。
- &a表示a对应的存储单元的地址。
- *a表示：首先，要求a对应的存储单元中的数据一定是另一个存储单元的地址。
- 于是，*a表示另一个存储单元中的数据。
当a声明的类型是int时，a中存储的是一个整数数值，通过a可以访问（读取或修改）这个数值。
当a声明的类型是int *时，a中存储的是一个存储单元的地址，而该存储单元中存储的数据是一个整数数值；
通过*a可以访问（读取或修改）这个数值。a == &a 都是该存储单元的地址。
当a声明的类型是int *时，a中存储的是一个存储单元的地址，而该存储单元中存储的数据是另外一个存储单元的地址，另外这个存储单元中存储的是一个整数数值；通过**a可以访问（读取或修改）这个数值。
1.4 指针
C语言中，地址也称指针。
计算机中所有数据都必须放在内存中，不同类型的数据所占的字节数不一样，如int型占用4字节，char占用一个字节。
我们将内存中字节的编号称为地址（address）或指针（pointer），地址从0开始依次增加。
1.4.1 指针的大小
指针是一个形无符号整型,一个整数,它的大小取决于系统是16 32 还是64位的 16/8=2byte 32/8=4byte 64/8=8byte.
1.4.2 指针指向的内容的大小
指针所指向的内存块所占内存大小.32位编译环境下，char占一个字节,int占2个字节,double占4个字节,long double占8个字节(这是默认的32位编译环境下,在64位下翻倍就是了),所以一个char指针所占内存为4个字节(32位下),所指向的内存区域占1个字节.同理其它类型也是一样的。
2.具体解析
2.1 普通变量（不带*）
int i = 100;
此时，普通变量变量名i即地址中的数据（变量值）,也就是100。存在一个地址：&i（表示唯一）。
简单理解：普通变量名=数据。
#include <stdio.h>
void test () {
int i = 100;
printf("i-----%i\n",i);
printf("&i----%p\n",&i);
}
int main(int argc, const char * argv[]) {
test();
return 0;
}
控制台输出
i-----100
&i----0x7ffeefbff51c
2.2 一级指针变量
int *a = &i;
一级指针变量：变量名a实际所指的内容为变量i的地址，即a=&i=&(*a)=*(&a);其中*a表示通过a中的内容（i的地址）取值即i。存在两个地址：&a（唯一表示方式）和a（表示方式不唯一，如上）。
简单理解：指针变量名=地址-------->数据。
#include <stdio.h>
void test () {
int i = 100;
printf("i-----%i\n",i);
printf("&i----%p\n",&i);
int *a;
printf("a-----%p\n",a);
printf("&a----%p\n",&a);
a = &i;
printf("a-----%p\n",a);
}
int main(int argc, const char * argv[]) {
test();
return 0;
}
控制台输出
i-----100
&i----0x7ffeefbff51c
a-----0x0
&a----0x7ffeefbff510
a-----0x7ffeefbff51c
Program ended with exit code: 0
变量a声明后没有赋值，其值为0，将&i(也就是i的地址)赋值给a后，a保存了i的地址，这是变量a对应的存储单元存储的数据，而a本身有自己的地址即自身存储单元的地址。（这里说存储单元并不是特别准确，应该是以a地址开头的存储块）
2.3 二级指针变量
int **p = &a;
二级指针变量：变量名p所指内容为一级指针的地址=&a=&(*p)=*(&p）=p，该地址（&（*p））中的内容是*p，其中*p中的内容为i的地址=&i=&（**p）=**（&p）=*p
（其中p=&a，a=&i）。
存在三个地址：&p（表示唯一）、p（表示不唯一）、*p（表示不唯一）。
简单理解：指针变量名=地址---------->地址------------>数据。
其中&（*）和*（&）相互抵消功能。
#include <stdio.h>
void test () {
int i = 100;
printf("i-----%i\n",i);
printf("&i----%p\n",&i);
int *a;
printf("a-----%p\n",a);
printf("&a----%p\n",&a);
a = &i;
printf("a-----%p\n",a);
int **p;
p = &a;
printf("p-----%p\n",p);
printf("*p----%p\n",*p);
printf("&p-----%p\n",&p);
}
int main(int argc, const char * argv[]) {
test();
return 0;
}
控制台输出
i-----100
&i----0x7ffeefbff51c
a-----0x0
&a----0x7ffeefbff510
a-----0x7ffeefbff51c
p-----0x7ffeefbff510
*p----0x7ffeefbff51c
&p-----0x7ffeefbff508
Program ended with exit code: 0
你可以尝试自己分析一下。
二级指针保存的是一级指针的地址，它的类型是指针变量，而一级指针保存的是指向数据所在的内存单元的地址，虽然都是地址，但是类型是不一样的。
3.指针与数组
C语言中由于指针的灵活性，导致指针能代替数组使用，或者混合使用。容易混淆的是字符数组和字符指针这两个,下面就这两个进行解析。
3.1字符数组
char str[10] = {"hello world"};
当编译这句代码时，编译器会将str数组中的元素从第一个元素开始逐个填入（hello world\0 ）。
由于C语言中没有真正的字符串类型，可以通过字符数组表示字符串，因为它的元素地址是连续的。
C语言中规定数组代表数组所在内存位置的首地址，也是 str[0]的地址，即str = &str[0];
让我们来看一个问题
printf("%s",str);
为什么用首地址就可以输出字符串。
在C语言中字符串常量的本质表示其实是一个地址。
3.2 字符指针
char *s ;
s = "Hello";
为什么可以把一个字符串赋给一个指针变量。。
这不是类型不一致吗？？？
C语言中编译器会给字符串常量分配地址，如果 "Hello", 存储在内存中的 0x3000 0x3001 0x3002 0x3003 0x3004 0x3005 .
s = "Hello" ，这是什么操作，对了，地址。
其实真正的意义是 s ="Hello" = 0x3000;
看清楚了吧 ，Hello 看作是字符串，但是编译器把它看作是地址 0x3000，即字符串常量的本质表现是代表它的第一个字符的地址。。。。。。。。。。
s = 0x3000
那么 %s ，它的原理其实也是通过字符串首地址输出字符串，printf("%s ", s); 传给它的其实是s所保存的字符串的地址。。。
字符数组：
char str[10] = "hello"；
前面已经说了，str = &str[0] ， 也等于 "hello"的首地址。。
所以printf("%s",str); 本质也是 printf("%s", 地址");
3.3 char * 与 char a[];
char *s;
char a[] ;
前面说到 a代表字符串的首地址，而s这个指针也保存字符串的地址（其实首地址），即第一个字符的地址，这个地址单元中的数据是一个字符，
这也与 s 所指向的 char 一致。
因此可以 s = a;
但是不能 a = s;
C语言中数组名可以复制给指针表示地址， 但是却不能赋给给数组名，它是一个常量类型，所以不能修改。。
3.4 char ** 与char * a[]
char *a [] ;
由于[] 的优先级高于* 所以a先和 []结合，他还是一个数组，数组中的元素才是char * ，前面讲到char * 是一个变量，保存的地址。。
所以 char *a[ ] = {"China","French","America","German"}；
同过这句可以看到， 数组中的元素是字符串，那么sizeof(a) 是多少呢，有人会想到是五个单词的占内存中的全部字节数 6+7+8+7 = 28；
但是其实sizeof(a) = 16；
为什么，前面已经说到， 字符串常量的本质是地址，a 数组中的元素为char * 指针，指针变量占四个字节（64bit编译器为8个字节），那么四个元素就是16个字节了
3.4.1 易错的char **
char **s = "hello world";
s的类型是 char ** 而 "hello world "的类型是 char *
虽然都是地址，但是指向的类型不一样，因此，不能这样用。从其本质来分析，"hello world",代表一个地址，比如0x003001,这个地址中的内容是 'h',为 char 型，而 s 也保存一个地址 ，这个地址中的内容(*s) 是char * ，是一个指针类型，所以两者类型是不一样的。
3.4.2 char **崩溃
char **s;
*s = "hello world";
上面的代码貌似是合理的，编译也没有问题，但是 printf("%s",*s),就会崩溃
why??
咱来慢慢推敲一下。。
printf("%s",*s); 时，首先得有s 保存的地址，再在这个地址中找到 char *的地址，即*s;
举例：
s = 0x1000;
在0x1000所在的内存单元中保存了"hello world"的地址 0x003001 ， *s = 0x003001;
这样printf("%s",*s);
这样会先找到 0x1000,然后找到0x003001;
如果直接 char **s;
*s = "hello world";
s 变量中保存的是一个无效随机不可用的地址， 谁也不知道它指向哪里。*s 操作会崩溃。。
所以用 char **s 时，要给它分配一个内存地址。
char **s ;
s = (char **) malloc(sizeof(char**));
*s = "hello world";
这样 s 给分配了了一个可用的地址，比如 s = 0x412f;
然后在 0x412f所在的内存中的位置，保存 "hello world"的值。
END
