p 称为指针变量,p 里存储的内存地址处的内存称为 p 所指向的内存。指针变量 p 里存储的任何数据都将被当作地址来处理
一个基本的数据类型(包括结构体等自定义类型)加上“*” 号就构成了一个指针类型的模子。这个模子的大小是一定的，与“*”号前面的数据类型无关。
“*”号前面的数据类型只是说明指针所指向的内存里存储的数据类型。所以，在 32 位系统下，不管什么样的指针类型，其大小都为 4byte。可以测试一下 sizeof(void *)。
int *p = NULL; 这时候通过编译器查看 p 的值为 0x00000000。这句代码的意思是:定义一个指针变量 p，其指向的内存里面保存的是 int 类型的数据;
在定义变量 p 的同时把 p 的值设置为 0x00000000，而不是把*p 的值设置为 0x00000000。
这个过程叫做初始化，是在编译的时候进行的。避免野指针，指向一段关键数据的地址造成数据的损毁
int *p; *p = NULL; 同样，我们可以在编译器上调试这两行代码。第一行代码，定义了一个指针变量 p，其指向的内存里面保存的是 int 类型的数据;但是这时候变量 p 本身的值是多少不得而知，也就是说现在变量 p 保存的有可能是一个非法的地址。第二行代码，给*p 赋值为 NULL，即给 p 指向的内存赋值为 NULL;但是由于 p 指向的内存可能是非法的，所以调试的时候编译器可能会报告一个内存访问错误。这样的话，我们可以把上面的代码改写改写，使 p 指向一块合法的内存:
int i = 10; int *p = &i; *p = NULL; 在编译器上调试一下，我们发现 p 指向的内存由原来的 10 变为 0 了;而 p 本身的值，即内存地址并没有改变。经过上面的分析，相信你已经明白它们之间的区别了。不过这里还有一个问题需要注意，也就是这个 NULL。初学者往往在这里犯错误。注意 NULL 就是 NULL，它被宏定义为 0:
#define NULL 0
很多系统下除了有 NULL 外，还有 NUL(Visual C++ 6.0 上提示说不认识 NUL)。NUL 是 ASCII 码表的第一个字符，表示的是空字符，其 ASCII 码值为 0。其值虽然都为 0，但表示的意思完全不一样。同样，NULL 和 0 表示的意思也完全不一样。一定不要混淆。
另外还有初学者在使用 NULL 的时候误写成 null 或 Null 等。这些都是不正确的，C 语言对大小写十分敏感啊。当然，也确实有系统也定义了 null，其意思也与 NULL 没有区别，但是你千万不用使用 null，这会影响你代码的移植性。

将数值存储到指定的内存地址

假设现在需要往内存 0x12ff7c 地址上存入一个整型数 0x100。我们怎么才能做到呢?我们知道可以通过一个指针向其指向的内存地址写入数据，那么这里的内存地址 0x12ff7c 其本质不就是一个指针嘛。所以我们可以用下面的方法: int *p = (int *)0x12ff7c; *p = 0x100;
需要注意的是将地址 0x12ff7c 赋值给指针变量 p 的时候必须强制转换。至于这里为什么选择内存地址 0x12ff7c，而不选择别的地址，比如 0xff00 等。这仅仅是为了方便在 Visual C++ 6.0 上测试而已。如果你选择 0xff00，也许在执行*p = 0x100;这条语句的时候，编译器会报告一个内存访问的错误，因为地址 0xff00 处的内存你可能并没有权力去访问。
既然这样，我们怎么知道一个内存地址是可以合法的被访问呢?也就是说你怎么知道地址 0x12ff7c 处的内存是可以被访问的呢?其实这很简单，我们可以先定义一个变量 i，比如:int i = 0; 变量 i 所处的内存肯定是可以被访问的。然后在编译器的 watch 窗口上观察&i 的值不就知道其内存地址了么?这里我得到的地址是 0x12ff7c，仅此而已(不同的编译器可能每次给变量 i 分配的内存地址不一样，而刚好 Visual C++ 6.0 每次都一样)。你完全可以给任意一个可以被合法访问的地址赋值。得到这个地址后再把“int i = 0;”这句代码删除。
*(int *)0x12ff7c = 0x100; 这行代码其实和上面的两行代码没有本质的区别。先将地址 0x12ff7c 强制转换，告诉编译器这个地址上将存储一个 int 类型的数据;然后通过钥匙“*”向这块内存写入一个数据。

如上图所示，当我们定义一个数组 a 时，编译器根据指定的元素个数和元素的类型分配确定大小(元素类型大小*元素个数)的一块内存，并把这块内存的名字命名为 a。名字 a 一旦与这块内存匹配就不能被改变。a[0],a[1]等为 a 的元素，但并非元素的名字。数组的每一个元素都是没有名字的。那现在再来回答第一章讲解 sizeof 关键字时的几个问题:
sizeof(a)的值为 sizeof(int)*5，32 位系统下为 20。
sizeof(a[0])的值为 sizeof(int)，32 位系统下为 4。
sizeof(a[5])的值在 32 位系统下为 4。并没有出错，为什么呢?我们讲过 sizeof 是关键字不是函数。函数求值是在运行的时候，而关键字 sizeof 求值是在编译的时候。虽然并不存在 a[5]这个元素，但是这里也并没有去真正访问 a[5],而是仅仅根据数组元素的类型来确定其值。所以这里使用 a[5]并不会出错。
sizeof(&a[0])的值在 32 位系下为 4，这很好理解。取元素 a[0]的首地址。 sizeof(&a)的值在 32 位系统下也为 4，这也很好理解。取数组 a 的首地址。
&a[0]和&a 的区别 a[0]是一个元素，a 是整个数组，虽然&a[0]和&a 的值一样，但其意义不一样。前者是数组首元素的首地址，而后者是数组的首地址。举个例子:湖南的省政府在长沙，而长沙的市政府也在长沙。两个政府都在长沙，但其代表的意义完全不同。这里也是同一个意思。

数组名 a 作为左值和右值的区别

简单而言，出现在赋值符“=”右边的就是右值，出现在赋值符“=”左边的就是左值。比如,x=y。
左值:在这个上下文环境中，编译器认为 x 的含义是 x 所代表的地址。这个地址只有编译器知道，在编译的时候确定，编译器在一个特定的区域保存这个地址，我们完全不必考虑这个地址保存在哪里。
右值:在这个上下文环境中，编译器认为 y 的含义是 y 所代表的地址里面的内容。这个内容是什么，只有到运行时才知道。
C 语言引入一个术语-----“可修改的左值”。意思就是，出现在赋值符左边的符号所代表的地址上的内容一定是可以被修改的。换句话说，就是我们只能给非只读变量赋值。
当 a 作为右值的时候代表的是什么意思呢?很多书认为是数组的首地址，其实这是非常错误的。a 作为右值时其意义与&a[0]是一样，代表的是数组首元素的首地址，而不是数组的首地址。这是两码事。但是注意，这仅仅是代表，并没有一个地方(这只是简单的这么认为，其具体实现细节不作过多讨论)来存储这个地址，也就是说编译器并没有为数组 a 分配一块内存来存其地址，这一点就与指针有很大的差别。
a 不能作为左值!编译器会认为数组名作为左值代表的意思是 a 的首元素的首地址，但是这个地址开始的一块内存是一个总体，我们只能访问数组的某个元素而无法把数组当一个总体进行访问。所以我们可以把 a[i]当左值，而无法把 a 当左值。其实我们完全可以把 a 当一个普通的变量来看，只不过这个变量内部分为很多小块，我们只能通过分别访问这些小块来达到访问整个变量 a 的目的。
A),char *p = “abcdef”;
B),char a[] = “123456”;

以指针的形式访问和以下标的形式访问指针

例子 A)定义了一个指针变量 p，p 本身在栈上占 4 个 byte，p 里存储的是一块内存的首地址。这块内存在静态区，其空间大小为 7 个 byte，这块内存也没有名字。对这块内存的访问完全是匿名的访问。比如现在需要读取字符‘e’，我们有两种方式:
1)，以指针的形式:*(p+4)。先取出 p 里存储的地址值，假设为 0x0000FF00，然后加上 4 个字符的偏移量，得到新的地址 0x0000FF04。然后取出 0x0000FF04 地址上的值。
2)，以下标的形式:p[4]。编译器总是把以下标的形式的操作解析为以指针的形式的操作。p[4]这个操作会被解析成:先取出 p 里存储的地址值，然后加上中括号中 4 个元素的偏移量，计算出新的地址，然后从新的地址中取出值。也就是说以下标的形式访问在本质上与以指针的形式访问没有区别，只是写法上不同罢了。
偏移量的单位是元素的个数而不是 byte 数

#include <iostream>int main(){int a[] = {1,2,3,4,5,6,7,8,9,10};int *ptr = (int*)(&a + 1);printf("%d,%d",*(a+1),*(ptr-1));
}

对指针进行加 1 操作，得到的是下一个元素的地址，而不是原有地址值直接加 1。所以，一个类型为 T 的指针的移动，以 sizeof(T) 为移动单位。因此，对上题来说，a 是一个一维数组，数组中有 5 个元素; ptr 是一个 int 型的指针。

这就是为什么 extern char a[]与 extern char a[100]等价的原因。因为这只是声明，不分配空间，所以编译器无需知道这个数组有多少个元素。这两个声明都告诉编译器 a 是在别的文件中被定义的一个数组，a 同时代表着数组 a 的首元素的首地址，也就是这块内存的起始地址。数组内地任何元素的的地址都只需要知道这个地址就可以计算出来。
但是，当你声明为 extern char *a 时，编译器理所当然的认为 a 是一个指针变量，在 32 位系统下，占 4 个 byte。这 4 个 byte 里保存了一个地址，这个地址上存的是字符类型数据。虽然在文件 1 中，编译器知道 a 是一个数组，但是在文件 2 中，编译器并不知道这点。大多数编译器是按文件分别编译的，编译器只按照本文件中声明的类型来处理。所以，虽然 a 实际大小为 100 个 byte，但是在文件 2 中，编译器认为 a 只占 4 个 byte。
编译器会把存在指针变量中的任何数据当作地址来处理。所以，如果需要访问这些字符类型数据，我们必须先从指针变量 a 中取出其保存的地址。如下图:

在文件 1 中，编译器分配 4 个 byte 空间，并命名为 p。同时 p 里保存了字符串常量“abcdefg” 的首字符的首地址。这个字符串常量本身保存在内存的静态区，其内容不可更改。
在文件 2 中，编译器认为 p 是一个数组，其大小为 4 个 byte，数组内保存的是 char 类型的数据。
在文件 2 中使用 p 的过程如下图:

指针数组和数组指针

初学者总是分不出指针数组与数组指针的区别。其实很好理解:
指针数组:首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。
数组指针:首先它是一个指针，它指向一个数组。在 32 位系统下永远是占 4 个字节，至于它指向的数组占多少字节，不知道。它是“指向数组的指针”的简称。
下面到底哪个是数组指针，哪个是指针数组呢:
- A)，int *p1[10]; 指针数组
- B)，int (*p2)[10]; 数组指针
这里需要明白一个符号之间的优先级问题。 “[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为 p1，int * 修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含 10 个指向 int 类型数据的指针，即指针数组。
至于 p2 就更好理解了，在这里“()”的优先级比 “[]”高，“*”号和 p2 构成一个指针的定义，指针变量名为 p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚 p2 是一个指针，它指向一个包含 10 个 int 类型数据的数组，即数组指针。
我们可以借助下面的图加深理解:

char a[5]={'A','B','C','D'};
char (*p3)[5] = &a; 正确
char (*p4)[5] = a; 需要类型转换
&a 是整个数组的首地址，a 是数组首元素的首地址，其值相同但意义不同

根据上面的讲解，&a+1 与 a+1 的区别已经清楚。
ptr1:将&a+1 的值强制转换成 int*类型，赋值给 int* 类型的变量 ptr，ptr1 肯定指到数组 a 的下一个 int 类型数据了。ptr1[-1]被解析成*(ptr1-1)，即 ptr1 往后退 4 个 byte。所以其值为 0x4。
ptr2:按照上面的讲解，(int)a+1 的值是元素 a[0]的第二个字节的地址。然后把这个地址强制转换成 int*类型的值赋给 ptr2，也就是说*ptr2 的值应该为元素 a[0]的第二个字节开始的连续4个byte的内容。
其内存布局如下图:

使用一个指针分配内存空间，复制数据
在运行 strcpy(str,”hello”)语句的时候发生错误。这时候观察 str 的值，发现仍然为 NULL。也就是说 str 本身并没有改变，我们 malloc 的内存的地址并没有赋给 str，而是赋给了_str。而这个_str 是编译器自动分配和回收的，我们根本就无法使用。所以想这样获取一块内存是不行的。那怎么办?
两个办法: 使用return返回内存空间
使用二级指针

注意，这里的参数是&str 而非 str。这样的话传递过去的是 str 的地址，是一个值。在函数内部，用钥匙(“*”)来开锁:*(&str)，其值就是 str。所以 malloc 分配的内存地址是真正赋值给了 str 本身。

函数指针

char * (*fun1)(char * p1,char * p2); fun1 指针变量指向的是一个函数

给函数指针赋值时，可以用&fun 或直接用函数名 fun。这是因为函数名被编译之后其实就是一个地址，所以这里两种用法没有本质的差别

(int)&p ----这是什么?

void (*p)(); 这行代码定义了一个指针变量 p，p 指向一个函数，这个函数的参数和返回值都是 void。
&p 是求指针变量 p 本身的地址，这是一个 32 位的二进制常数(32 位系统)。
(int*)&p 表示将地址强制转换成指向 int 类型数据的指针。
(int)Function 表示将函数的入口地址强制转换成 int 类型的数据。
*(int*)&p=(int)Function;表示将函数的入口地址赋值给指针变量 p。
那么(*p) ();就是表示对函数的调用。
其实函数指针与普通指针没什么差别，只是指向的内容不同而已。使用函数指针的好处在于，可以将实现同一功能的多个模块统一起来标识，这样一来更
容易后期的维护，系统结构更加清晰。或者归纳为:便于分层设计、利于系统抽象、降低耦合度以及使接口与实现分开。