一、指针的概念
要知道指针的概念，要先了解变量在内存中如何存储的。在存储时，内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针，就像酒店的门牌号一样。
1.1、变量和地址
先写一段简单的代码：
void main(){
	int x = 10, int y = 20;
}

这段代码非常简单，就是两个变量的声明，分别赋值了 10、20。我们把内存当做一个酒店，而每个房间就是一块内存。那么“int x = 10;”和“int y = 20;”的实际含义如下：

去酒店订了两个房间，门牌号暂时用 px、py 表示
让 10 住进 px，让 20 住进 py
其中门牌号就是 px、py 就是变量的地址
x 和 y 在这里可以理解为具体的房间，房间 x 的门牌号（地址）是 px，房间 y 的门牌号（地址）是 py。而 10 和 20，通过 px、py 两个门牌，找到房间，住进 x、y。

1.2、指针变量和指针的类型
指针变量就是一个变量，它存储的内容是一个指针。如果用前面的例子，可以理解为指针变量就是一张房卡，房卡存储了房间号的信息。
在我们定义一个变量的时候，要确定它的类型。int x、char ch、float、、、在定义指针变量时也是一样的，必须确定指针类型。int 变量的指针需要用 int 类型的指针存储，float 变量的指针需要用 float 类型的指针存储。就像你只能用酒店 A 的房卡存储酒店 A 中房间号的信息一样。
二、变量的指针与指针变量
变量的指针就是变量的存储地址，指针变量就是存储指针的变量。
2.1、指针变量的定义及使用
（1）指针变量的定义
指针变量的定义形式如：数据类型 *指针名;例如：
//分别定义了 int、float、char 类型的指针变量
int *x;
float *f;
char *ch;

如上面的定义，指针变量名为 x、f、ch。并不是*x、*f、*ch
（2）指针变量的使用

取地址运算符&：单目运算符&是用来取操作对象的地址。例：&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址（因为它们存储在存储器中，没有地址）。
指针运算符*（间接寻址符）：与&为逆运算，作用是通过操作对象的地址，获取存储的内容。例：x = &i，x 为 i 的地址，*x 则为通过 i 的地址，获取 i 的内容。

代码示例：
//声明了一个普通变量 a
int a;
//声明一个指针变量，指向变量 a 的地址
int *pa;
//通过取地址符&，获取 a 的地址，赋值给指针变量
pa = &a;
//通过间接寻址符，获取指针指向的内容
printf("%d", *pa);

（3）“&”和“*”的结合方向
“&”和“*”都是右结合的。假设有变量 x = 10，则*&x 的含义是，先获取变量 x 的地址，再获取地址中的内容。因为“&”和“*”互为逆运算，所以 x = *&x。
接下来做个小练习，输入 x、y 两个整数，然后将其中的值大的赋值给 x，小的赋值给 y。即：假设输入 x = 8，y = 9。就将 9 赋值给 x，8 赋值给 y。
void main(){
	//声明两个普通变量
	int x, y;
	//声明两个指针变量
	int *px, *py;
	//声明一个临时变量，用于交换
	int t;
	//输入两个值，赋值给 x、y
	scanf("%d", &x);
	scanf("%d", &y);
	//给指针变量 px、py 赋初值（关联变量 x、y）
	px = &x;
	py = &y;
	//利用指针来对比 x、y 的值，如果 x 的值比 y 的值小，就交换
	if(*px < *py){
		//交换步骤，其中*px == x、*py == y
		t = *px;
		*px = *py;
		*py = t;
	}
	printf("x =  %d, y = %d", *px, *py);
}

输入：23 45
输出结果为：x = 45, y = 23

2.2、指针变量的初始化
指针变量与其它变量一样，在定义时可以赋值，即初始化。也可以赋值“NULL”或“0”，如果赋值“0”，此时的“0”含义并不是数字“0”，而是 NULL 的字符码值。
//利用取地址获取 x 的地址，在指针变量 px 定义时，赋值给 px
int x;
int *px = &x;
//定义指针变量，分别赋值“NULL”和“0”
int *p1= NULL, *p2 = 0;

2.3、指针运算
（1）赋值运算
指针变量可以互相赋值，也可以赋值某个变量的地址，或者赋值一个具体的地址
int *px, *py, *pz, x = 10;
//赋予某个变量的地址
px = &x;
//相互赋值
py = px;
//赋值具体的地址
pz = 4000;

（2）指针与整数的加减运算

指针变量的自增自减运算。指针加 1 或减 1 运算，表示指针向前或向后移动一个单元（不同类型的指针，单元长度不同）。这个在数组中非常常用。
指针变量加上或减去一个整形数。和第一条类似，具体加几就是向前移动几个单元，减几就是向后移动几个单元。

//定义三个变量，假设它们地址为连续的，分别为 4000、4004、4008
int x, y, z;

//定义一个指针，指向 x
int *px = &x;

//利用指针变量 px 加减整数，分别输出 x、y、z
printf("x = %d", *px);		//因为 px 指向 x，所以*px = x

//px + 1，表示，向前移动一个单元（从 4000 到 4004）
//这里要先(px + 1)，再*(px + 1)获取内容，因为单目运算符“*”优先级高于双目运算符“+”
printf("y = %d", *(px + 1));		
printf("z = %d", *(px + 2));

（3）关系运算
假设有指针变量 px、py。

px > py 表示 px 指向的存储地址是否大于 py 指向的地址
px == py 表示 px 和 py 是否指向同一个存储单元
px == 0 和 px != 0 表示 px 是否为空指针

//定义一个数组，数组中相邻元素地址间隔一个单元
int num[2] = {1, 3};

//将数组中第一个元素地址和第二个元素的地址赋值给 px、py
int *px = &num[0], *py = &num[1];
int *pz = &num[0];
int *pn;

//则 py > px
if(py > px){
	printf("py 指向的存储地址大于 px 所指向的存储地址");
}

//pz 和 px 都指向 num[0]
if(pz == px){
	printf("px 和 pz 指向同一个地址");
}

//pn 没有初始化
if(pn == NULL || pn == 0){
	printf("pn 是一个空指针");
}

三、指针与数组
之前我们可以通过下标访问数组元素，学习了指针之后，我们可以通过指针访问数组的元素。在数组中，数组名即为该数组的首地址，结合上面指针和整数的加减，我们就可以实现指针访问数组元素。
3.1、指向数组的指针
如以下语句：
int nums[10], *p;

上面语句定义了一个数组 nums，在定义时分配了 10 个连续的int 内存空间。而一个数组的首地址即为数组名nums，或者第一个元素的首地址也是数组的首地址。那么有两种方式让指针变量 p 指向数组 nums：
//数组名即为数组的首地址
p = nums;
//数组第一个元素的地址也是数组的首地址
p = &nums[0];

上面两句是等价的。

如下几个操作，用指针操作数组：

*p = 1，此操作为赋值操作，即将指针指向的存储空间赋值为 1。此时 p 指向数组 nums 的第一个元素，则此操作将 nums 第一个元素赋值为 0，即 nums[0] = 1。
p + 1，此操作为指针加整数操作，即向前移动一个单元。此时 p + 1 指向 nums[0]的下一个元素，即 nums[1]。通过p + 整数可以移动到想要操作的元素（此整数可以为负数）。
如上面，p（p + 0）指向 nums[0]、p + 1 指向 nums[1]、、、类推可得，p+i 指向 nums[i]，由此可以准确操作指定位置的元素。
在 p + 整数的操作要考虑边界的问题，如一个数组长度为 2，p+3 的意义对于数组操作来说没有意义。

下面写一段代码，用指针访问数组的元素：
//定义一个整形数组，并初始化
int nums[5] = {4, 5, 3, 2, 7};

//定义一个指针变量 p，将数组 nums 的首地址赋值给 p，也可以用p = &nums[0]赋值
int *p = nums, i;			//i 作为循环变量

//p 指向数组第一个元素（数组首地址），我们可以直接用间接寻址符，获取第一个元素的内容
printf("nums[0] = %d\n", *p);			//输出结果为 nums[0] = 4

//我们可以通过“p + 整数”来移动指针，要先移动地址，所以 p + 1 要扩起来
printf("nums[1] = %d\n", *(p + 1));		//输出结果为 nums[1] = 5

//由上面推导出*(p + i) = nums[i]，所以我们可以通过 for 循环变量元素
for(i = 0; i < 5; i++){
	printf("nums[%d] = %d", i, *(p + i));
}

注：数组名不等价于指针变量，指针变量可以进行 p++和&操作，而这些操作对于数组名是非法的。数组名在编译时是确定的，在程序运行期间算一个常量。
3.2、字符指针与字符数组
在 C 语言中本身没有提供字符串数据类型，但是可以通过字符数组和字符指针的方式存储字符串。
（1）字符数组方式
这个在前面应该学习过，这里就不赘述了。
char word[] = "zack";
printf("%s", word);

（2）字符指针方式
指针方式操作字符串和数组操作字符串类似，可以把定义的指针看做是字符数组的数组名。在内存中存储大致如下，这里为了方便换了个字符串：
//除了定义一个字符数组外，还可以直接定义一个字符指针存储字符串
char *sentence = "Do not go gentle into that good night!";

//此时可以做字符串的操作
//输出
printf("%s", sentence);

//通过下标取字符
printf("%c", sentence[0]);

//获取字符串长度，其中 strlen 是 string.h 库中的方法
printf("%d", strlen(sentence));

注：字符指针方式区别于字符数组方式，字符数组不能通过数组名自增操作，但是字符指针是指针，可以自增操作。自增自减少会实现什么效果大家可以自己尝试运行一下
下面做个小练习，利用字符指针将字符数组 sentence 中的内容复制到字符数组 word 中：
//定义字符数组 sentence 和 word，给 sentence 赋初值
char sentence[] = "Do not go gentle into that good night!", word[100];

//定义字符指针，指向 word
char *ch = word;
int i;

//循环赋值
for(i = 0; sentence[i] != '\0'; i++){
	*(ch + i) = sentence[i];
}

//在当 i 等于 sentence 的长度（sentence 的长度不包含'\0'）时，
//i 继续自增，此时判断 sentence[0] != '\0'不符合，跳出循环，则 i 比 sentence 长度大 1
*(ch + i) = '\0';

//输出字符串，因为 ch 指向 word，所以输出结果是一样的
printf("ch = %s, word = %s", ch, word);

注：指针变量必须初始化一个有效值才能使用
3.3、多级指针及指针数组
（1）多级指针
指针变量作为一个变量也有自己的存储地址，而指向指针变量的存储地址就被称为指针的指针，即二级指针。依次叠加，就形成了多级指针。我们先看看二级指针，它们关系如下：

其中 p 为一级指针，pp 为二级指针。二级指针定义形式如下：
数据类型 **二级指针名;

和指针变量的定义类似，由于*是右结合的，所以*pp 相当于*(*p)。在本次定义中，二级指针的变量名为 pp，而不是**p。多级指针的定义就是定义时使用多个“*”号。下面用一个小程序给大家举例：
//定义普通变量和指针变量
int *pi, i = 10;
//定义二级指针变量
int **ppi;

//给指针变量赋初值
pi = &i;

//给二级指针变量赋初值
ppi = &pi;

//我们可以直接用二级指针做普通指针的操作
//获取 i 的内容
printf("i = %d", **ppi);
//获取 i 的地址
printf("i 的地址为%d", *ppi);

注：在初始化二级指针 ppi 时，不能直接 ppi = &&i，因为&i 获取的是一个具体的数值，而具体数字是没有指针的。
（2）指针数组
指针变量和普通变量一样，也能组成数组，指针数组的具体定义如下：
数据类型 *数组名[指针数组长度];

下面举一个简单的例子熟悉指针数组：
//定义一个数组
int nums[5] = {2, 3, 4, 5, 2}, i;

//定义一个指针数组
int *p[5];

//定义一个二级指针
int **pp;

//循环给指针数组赋值
for(i = 0; i < 5; i++){
	p[i] = &nums[i];
}

//将指针数组的首地址赋值给 pp，数组 p 的数组名作为 p 的首地址，也作为 p 中第一个元素的地址。
//数组存放的内容为普通变量，则数组名为变量的指针；数组存放的内容为指针，则数组名为指针的指针。
pp = p;

//利用二级指针 pp 输出数组元素
for(i = 0; i < 5; i++){
	//pp == &p[0] == &&nums[0]，nums[0] == *p[0] == **pp
	printf("%d", **pp);
	
	//指针变量+整数的操作，即移动指针至下一个单元
	pp++;
}

3.4、指针与多维数组
讲多维数组是个麻烦的事，因为多维数组和二维数组没有本质的区别，但是复杂度倒是高了许多。这里我主要还是用二维数组来举例，但是还是会给大家分析多维数组和指针的关系。
（1）多维数组的地址
先用一个简单的数组来举例：
int nums[2][2] = {
	{1, 2},
	{2, 3}
};

我们可以从两个维度来分析：

先是第一个维度，将数组当成一种数据类型 x，那么二维数组就可以当成一个元素为 x 的一维数组。
如上面的例子，将数组看成数据类型 x，那么 nums 就有两个元素。nums[0]和 nums[1]。
我们取 nums[0]分析。将 nums[0]看做一个整体，作为一个名称可以用 x1 替换。则 x1[0]就是 nums[0][0]，其值为 1。



我们知道数组名即为数组首地址，上面的二维数组有两个维度。首先我们把按照上面 1 来理解，那么 nums 就是一个数组，则nums 就作为这个数组的首地址。第二个维度还是取 nums[0]，我们把 nums[0]作为一个名称，其中有两个元素。我们可以尝试以下语句：
printf("%d", nums[0]);

此语句的输出结果为一个指针，在实验过后，发现就是 nums[0][0]的地址。即数组第一个元素的地址。
如果再多一个维度，我们可以把二维数组看做一种数据类型 y，而三维数组就是一个变量为 y 的一维数组。而数组的地址我们要先确定是在哪个维度，再将数组某些维度看成一个整体，作为名称，此名称就是该维度的地址（这里有些绕）。
例：
//假设已初始化，二维数组数据类型设为 x，一维数组数据类型设为 y
int nums[2][2][2];

//此数组首地址为该数组名称
printf("此数组首地址为%d", nums);

//此数组可以看做存储了两个 x 类型元素的一维数组，则 nums[0] = x1 的地址为
printf("第二个维度的首地址为%d", nums[0]);

//而 x1 可以看做存储了两个 y 类型元素的一维数组，则 y1 = x1[0] = nums[0][0]
printf("第三个维度的首地址为%d", nums[0][0]);


三维数组实际存储形式如下：



实际存储内容的为最内层维度，且为连续的。对于 a 来说，其个跨度为 4 个单元；对 a[0]来说，其跨度为 2 个单元；对 a[0][0]来说，跨度为一个单元。有上面还可以得出：
a == a[0] == a[0][0] == &a[0][0][0];

上面的等式只是数值上相等，性质不同。
（2）多维数组的指针
在学习指针与数组的时候，我们可以如下表示一个数组：
int nums[5] = {2, 4, 5, 6, 7};
int *p = nums;

在前面讲指针数组时，所有指针数组元素都指向一个数字，那么我们现在可以尝试用指针数组的每个元素指向一个数组：
//定义一个二维数组
int nums[2][2] = {
	{1, 2},
	{2, 3}
};

//此时 nums[0]、和 nums[1]各为一个数组
int *p[2] = {nums[0], nums[1]};

//我们可以用指针数组 p 操作一个二维数组

//p 为数组 p 的首地址，p[0] = nums[0] = *p，**p = nums[0][0]
printf("nums[0][0] = %d", **p);

//指针 + 整数形式，p+1 移动到 nums 的地址，*(p +1) = nums[1]，则**(p + 1) = nums[1][0]
printf("nums[1][0] = %d", **(p + 1));

//先*p = nums[0]，再*p + 1 = &nums[0][1]，最后获取内容*(*p + 1)即为 nums[0][1]
printf("nums[0][1] = %d", *(*p + 1));

这里可能不能理解为什么*p + 1 = &nums[0][1]，而不是 nums[1]。*p 获得的是一个一维数组，而 int 数组 + 1 的跨度只有 4 个字节，也就是一个单元。前面 p 是一维数组的指针，其跨度为一个数组。所以*p + 1 = &nums[0][1]，而 p + 1 = nums[1]。
四、指针与函数
前面学习函数学到，函数参数可以为 int、char、float 等，但是在操作时，这些参数只作为形参，所有操作都只在函数体内有效（除对指针的操作外），那么今天来学习一下指针作为函数参数。
4.1、函数参数为指针
我们直接做一个练习，定义一个函数，用来交换两个变量的内容。
void swap(int *x, int *y);
void main(){
	int x = 20, y = 10;
	swap(&x, &y);
	printf("x = %d, y = %d", x ,y);
}
void swap(int *x, int *y){
	int t;
	t = *x;
	*x = *y;
	*y = t;
}

代码非常简单，我也就不细讲了。这里传入的参数为指针，所以调用 swap 方法后 x，y 的内容发生了交换。如果直接传入 x，y，那么交换只在 swap 中有效，在 main 中并没有交换。
4.2、函数的返回值为指针
返回值为指针的函数声明如下：
数据类型 *函数名(参数列表){
	函数体
}
//例如：
int s;
int *sum(int x, int y){
	s = x + y;
	return &s;
}

在函数调用前要声明需要对函数声明（有点编译器不需要）
int s;
void mian(){
	int *r = sum(10, 9);
	printf("10 + 9 + %d", *r);
}
int *sum(int x, int y){
	s = x + y;
	return &s;
}

除了上面的操作，更实用的是返回一个指向数组的指针，这样就实现了返回值为数组。
4.3、指向函数的指针
C 语言中，函数不能嵌套定义，也不能将函数作为参数传递。但是函数有个特性，即函数名为该函数的入口地址。我们可以定义一个指针指向该地址，将指针作为参数传递。
函数指针定义如下：
数据类型 (*函数指针名)();

函数指针在进行“*”操作时，可以理解为执行该函数。函数指针不同与数据指针，不能进行+整数操作。
下面举个例子，来使用函数指针：
#include <string.h>
/**
*	定义一个方法，传入两个字符串和一个函数指针 p，用 p 对两个字符串进行操作
*/
void check(char *x, char *y, int (*p)());
void main(){
	//string.h 库中的函数，使用之前需要声明该函数。字符串比较函数
	int strcmp();
	char x[] = "Zack";
	char y[] = "Rudy";
	
	//定义一个函数指针
	int (*p)() = strcmp;

	check(x, y, p);
}
void check(char *x, char *y, int (*p)()){
	if(!(*p)(x, y)){
		printf("相等");
	}else{
		printf("不相等");
	}
}

利用函数指针调用方法具体操作如下：
(*p)(x, y);

指针除了这些地方，还在结构体中用处巨大。今天就先讲到这里~·

目录

一、指针变量的定义和使用

       1.定义指针变量

       2.通过指针变量取得数据

       3.关于*和&

二、指针变量运算(加法、减法、比较运算)

三、数组指针(指向数组的指针)

       假设 p 是指向数组 arr 中第 n 个元素的指针，那么 *p++、*++p、(*p)++ 分别是什么意思呢？

四、字符串指针(指向字符串的指针)

       字符数组&&字符串常量

五、数组灵活多变的访问形式

六、指针变量作为函数参数

七、指针作为函数返回值

八、二级指针(指向指针的指针）

九、空指针NULL与void指针

       1.空指针NULL

       2.void 指针

十、数组≠指针

       1.数组在什么时候会转换为指针

       2.关于数组和指针可交换性的总结

十一、C语言指针数组（每个元素都是指针）

十二、函数指针（指向函数的指针）

十三、总结

 

       所谓指针，也就是内存的地址；所谓指针变量，也就是保存了内存地址的变量。

       需要注意的是，虽然变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符，但在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址。

一、指针变量的定义和使用

       数据在内存中的地址也称为指针，如果一个变量存储了一份数据的指针，我们就称它为指针变量。

       在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。指针变量的值就是某份数据的地址，这样的一份数据可以是数组、字符串、函数，也可以是另外一个普通变量或者指针变量。

       假设有一个char类型的变量c，它存储了字符'K'，并占用了地址为0x11A的内存(地址通常用十六进制表示)。另外有一个指针变量p，它的值为0x11A，正好等于变量c的地址，这种情况我们就称p指向了c，或者说p是指向变量c的指针。



       1.定义指针变量

       定义指针变量与定义普通变量非常类似，不过要在变量名前面加星号*，格式为：

datatype *name;  或者  datatype *name = value;
其中，*表示这是一个指针变量，datatype表示该指针变量所指向的数据的类型。

       *是一个特殊符号，表明一个变量是指针变量，定义指针变量时必须带*。而给指针变量赋值时，因为已经知道了它是一个指针变量，就没必要多此一举再带上*，后边可以像使用普通变量一样来使用指针变量。也就是说，定义指针变量时必须带*，给指针变量赋值时不能带*。

int *p1;//p1 是一个指向 int 类型数据的指针变量

int a = 100;
int *p_a = &a;//在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 需要的一个地址，a 前面必须要加取地址符&，否则是不对的。

//定义普通变量
float a = 99.5, b = 10.6;
char c = '@', d = '#';
//定义指针变量
float *p1 = &a;
char *p2 = &c;
//修改指针变量的值
p1 = &b;
p2 = &d;
//*是一个特殊符号，表明一个变量是指针变量，定义 p1、p2 时必须带*。而给 p1、p2 赋值时，因为已经知道了它是一个指针变量，就没必要多此一举再带上*，后边可以像使用普通变量一样来使用指针变量。也就是说，定义指针变量时必须带*，给指针变量赋值时不能带*。
注：需要强调的是，p1、p2 的类型分别是float*和char*，而不是float和char，它们是完全不同的数据类型，要引起注意。

       指针变量也可以连续定义：

int *a, *b, *c;  //a、b、c 的类型都是 int*
注意每个变量前面都要带*。如果写成下面的形式，那么只有 a 是指针变量，b、c 都是类型为 int 的普通变量：
int *a, b, c;

       2.通过指针变量取得数据

       指针变量存储了数据的地址，通过指针变量能够获得该地址上的数据，格式为：

*pointer;  其中，*称为指针运算符，用来取得某个地址上的数据，

  *在不同的场景下有不同的作用：*可以用在指针变量的定义中，表明这是一个指针变量，以和普通变量区分开；使用指针变量时在前面加*表示获取指针指向的数据，或者说表示的是指针指向的数据本身。 

//通过指针变量取得数据
#include <stdio.h>
int main(){
	int a = 15;
	int *p = &a;
	printf("%d,%d\n",a,*p);//两种方式均可输出a的值
	return 0;
}
//运行结果：15,15
//解析：假设 a 的地址是 0X1000，p 指向 a 后，p 本身的值也会变为 0X1000，*p 表示获取地址 0X1000 上的数据，也即变量 a 的值。从运行结果看，*p 和 a 是等价的。

       我们知道CPU 读写数据必须要知道数据在内存中的地址，普通变量和指针变量都是地址的助记符，虽然通过 *p 和 a 获取到的数据一样，但它们的运行过程稍有不同：a 只需要一次运算就能够取得数据，而 *p 要经过两次运算，多了一层“间接”。

       假设变量 a、p 的地址分别为 0X1000、0XF0A0，它们的指向关系如下图所示：



       程序被编译和链接后，a、p 被替换成相应的地址。使用 *p 的话，要先通过地址 0XF0A0 取得变量 p 本身的值，这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据，前后共有两次运算；而使用 a 的话，可以通过地址 0X1000 直接取得它的数据，只需要一步运算。也就是说，使用指针是间接获取数据，使用变量名是直接获取数据，前者比后者的代价要高。

//指针修改内存上的数据
#include <stdio.h>
int main(){
	int a = 15, b = 99, c = 222;
	int *p = &a;//定义指针变量
	*p = b;//通过指针变量修改内存上的数据
	c = *p;//通过指针变量获取内存上的数据
	printf("%d, %d, %d, %d\n",a,b,c,*p);
	return 0;
}
//运行结果：15,15
//解析：p指向a，这时*p值为15，*p=b，内存上的值变为99，此时a中的值也变为99。最后c=*p，c中的值也变为99

        定义指针变量时的 * 和使用指针变量时的 * 区别： 

int *p = &a;//*用在指针变量的定义中，表明这是一个指针变量，以和普通变量区分开；
*p = 100;//在指针变量前面加*表示获取指针指向的数据

需要注意的是，给指针变量本身赋值时不能加*，如：
int *p;
p = &a;//如果写成*p = &a,报错！！！
*p = 100

//通过指针交换两个变量的值
#include <stdio.h>
int main(){
	int a = 100, b = 999, temp;
	int *pa = &a, *pb = &b;
	printf("a=%d,b=%d\n", a, b);
	//开始交换
	temp = *pa;
	*pa = *pb;
	*pb = temp;
	//结束交换

	printf("a=%d,b=%d\n", a, b);
	return 0;
}
//运行结果：
a=100,b=999
a=999,b=100

       3.关于*和&

int a;
int *p = &a;
*&a表示什么？*&a可以理解为*(&a)，&a表示取变量a的地址(即p)，*(&a)表示取这个地址上的数据(即*p),绕来绕去，*&a仍然等于a。
&*p表示什么？&*p可以理解为&(*p)，*p表示取得p指向的数据(即a)，&(*p)表示数据的地址(即&a)，所以等于p。

       星号*主要有三种用途：

       ①表示乘法，例如int a = 3, b = 5, c;  c = a * b;，这是最容易理解的。

       ②表示定义一个指针变量，以和普通变量区分开，例如int a = 100;  int *p = &a;。

       ③表示获取指针指向的数据，是一种间接操作，例如int a, b, *p = &a;  *p = 100;  b = *p;。

二、指针变量运算(加法、减法、比较运算)

       指针变量保存的是地址，而地址本质上是一个整数，所以指针变量可以进行部分运算，例如加法、减法、比较等。但是不能对指针变量进行乘法、除法、取余等其他运算，除了会发生语法错误，也没有实际的含义。

#include <stdio.h>
int main(){
	int a = 10, *pa = &a, *paa = &a;
	double b = 99.9, *pb = &b;
	char c = '@', *pc = &c;
	//最初的值
	printf("&a=%#X,&b=%#X,&c=%#X\n",&a,&b,&c);
	printf("pa=%#X,pb=%#X,pc=%#X\n",pa,pb,pc);
	//加法运算
	pa++; pb++; pc++;
	printf("pa=%#X,pb=%#X,pc=%#X\n",pa,pb,pc);
	//减法运算
	pa -= 2; pb -= 2; pc -= 2;
	printf("pa=%#X,pb=%#X,pc=%#X\n",pa,pb,pc);
	//比较运算
	if (pa == paa){
		printf("%d\n", *paa);//比较的是指针变量本身的值，也就是数据的地址。如果地址相等，那么两个指针就指向同一份数据.
	}
	else{
		printf("%d\n",*pa);
	}
	return 0;
}
//运行结果：
&a=0X98FB00,&b=0X98FAD8,&c=0X98FAC3
pa=0X98FB00,pb=0X98FAD8,pc=0X98FAC3
pa=0X98FB04,pb=0X98FAE0,pc=0X98FAC4
pa=0X98FAFC,pb=0X98FAD0,pc=0X98FAC2
-858993460

三、数组指针(指向数组的指针)

       数组（Array）是一系列具有相同类型的数据的集合，每一份数据叫做一个数组元素（Element）。数组中的所有元素在内存中是连续排列的，整个数组占用的是一块内存。以int arr[] = { 99, 15, 100, 888, 252 };为例，该数组在内存中的分布如下图所示：



       定义数组时，要给出数组名和数组长度，数组名可以认为是一个指针，它指向数组的第 0 个元素。在C语言中，我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例，下图是 arr 的指向：




       数组名的本意是表示整个数组，也就是表示多份数据的集合，但在使用过程中经常会转换为指向数组第 0 个元素的指针，所以上面使用了“认为”一词，表示数组名和数组首地址并不总是等价。初学者可以暂时忽略这个细节，把数组名当做指向第 0 个元素的指针使用即可。


       如果一个指针指向了数组，我们就称它为数组指针（Array Pointer），定义一个指向数组的指针例子如下：

int arr[] = {23, 56, 4, 34, 45 };
int *p = arr;
arr 本身就是一个指针，可以直接赋值给指针变量 p。arr 是数组第 0 个元素的地址，所以int *p = arr;也可以写作int *p = &arr[0];。也就是说，arr、p、&arr[0] 这三种写法都是等价的，它们都指向数组第 0 个元素，或者说指向数组的开头。

       数组指针指向的是数组中的一个具体元素，而不是整个数组，所以数组指针的类型和数组元素的类型有关，上面的例子中，p 指向的数组元素是 int 类型，所以 p 的类型必须也是int *。

//①使用指针的方式遍历数组元素
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int len = sizeof(arr) / sizeof(int);//求数组长度，sizeof(arr) 会获得整个数组所占用的字节数，sizeof(int) 会获得一个数组元素所占用的字节数，它们相除的结果就是数组包含的元素个数，也即数组长度。
	int i;
	for (i = 0; i < len; i++){
		printf("%d ", *(arr + i));//*(arr+i)等价于arr[i]，arr 是数组名，指向数组的第 0 个元素，表示数组首地址， arr+i 指向数组的第 i 个元素，*(arr+i) 表示取第 i 个元素的数据，它等价于 arr[i]。
	}
	printf("\n");
	return 0;
}
//运行结果：23 56 4 34 45

//②使用数组指针来遍历数组元素
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int i, *p = arr, len = sizeof(arr) / sizeof(int);
    //求数组的长度时不能使用sizeof(p) / sizeof(int)，因为 p 只是一个指向 int 类型的指针，编译器并不知道它指向的到底是一个整数还是一系列整数（数组），所以 sizeof(p) 求得的是 p 这个指针变量本身所占用的字节数，而不是整个数组占用的字节数。

	for (i = 0; i < len; i++){
		printf("%d ", *(p + i));
	}
	printf("\n");
	return 0;
}
//运行结果：23 56 4 34 45

//③让 p 指向数组中的第三个元素
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int *p = &arr[2];//也可以写做int *p = arr +2，这里指向第三个元素
	printf("%d,%d,%d\n",*(p-2),*p,*(p+2));
	return 0;
}
//运行结果：23,4,45

       引入数组指针后，我们就有两种方案来访问数组元素了，一种是使用下标，另外一种是使用指针。

       (1) 使用下标

       也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针，那么也可以使用 p[i] 来访问数组元素，它等价于 arr[i]。

       (2) 使用指针

       也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针，也可以使用 *(arr+i) 来访问数组元素，它等价于 *(p+i)。


       不管是数组名还是数组指针，都可以使用上面的两种方式来访问数组元素。不同的是，数组名是常量，它的值不能改变，而数组指针是变量（除非特别指明它是常量），它的值可以任意改变。也就是说，数组名只能指向数组的开头，而数组指针可以先指向数组开头，再指向其他元素。

       假设 p 是指向数组 arr 中第 n 个元素的指针，那么 *p++、*++p、(*p)++ 分别是什么意思呢？

//*p++
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int i, *p = arr, len = sizeof(arr) / sizeof(int);

	for (i = 0; i < len; i++){
		printf("%d ", *p++);
	}
	printf("\n");
	return 0;
}
//运行结果：23 56 4 34 45
//解析：*p++ 应该理解为 *(p++)，每次循环都会改变 p 的值（p++ 使得 p 自身的值增加），以使 p 指向下一个数组元素。该语句不能写为 *arr++，因为 arr 是常量，而 arr++ 会改变它的值，这显然是错误的。

//*++p
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int i, *p = arr, len = sizeof(arr) / sizeof(int);

	for (i = 0; i < len; i++){
		printf("%d ", *++p);
	}
	printf("\n");
	return 0;
}
//运行结果：56 4 34 45 -858993460
//解析：*++p 等价于 *(++p)，会先进行 ++p 运算，使得 p 的值增加，指向下一个元素，整体上相当于 *(p+1)，所以会获得第 n+1 个数组元素的值。最后一个值为随机值。

//(*p)++
#include <stdio.h>
int main(){
	int arr[] = { 23, 56, 4, 34, 45 };
	int i, *p = arr, len = sizeof(arr) / sizeof(int);

	for (i = 0; i < len; i++){
		printf("%d ", (*p)++);
	}
	printf("\n");
	return 0;
}
//运行结果：23 24 25 26 27
//解析：(*p)++ 就非常简单了，会先取得第1个元素的值，再对该元素的值加 1。这里第1个元素的值为 23，执行完该循环语句后，第 1个元素的值依次会变为 24 25 26 27。

四、字符串指针(指向字符串的指针)

       C语言没有字符串类型，通常是将字符串放在一个字符数组中。使用指针的方式输出字符串：

#include <stdio.h>
#include <string.h>
int main(){
	char str[] = "www.baidu.com";
	char *pstr = str;
	int len = strlen(str), i;

	//使用*(pstr+i)
	for (i = 0; i < len; i++){
		printf("%c", *(pstr + i));
	}
	printf("\n");

	//使用pstr[i]
	for (i = 0; i < len; i++){
		printf("%c", pstr[i]);
	}
	printf("\n");

	//使用*(str+i)
	for (i = 0; i < len; i++){
		printf("%c",*(str+i));
	}
	printf("\n");

	return 0;
}
//运行结果：
www.baidu.com
www.baidu.com
www.baidu.com

       除了字符数组，C语言还支持另外一种表示字符串的方法，就是直接使用一个指针指向字符串，例如：

char *str = "www.baidu.com";
或者
char *str;
str = "www.baidu.com";
//字符串中的所有字符在内存中是连续排列的，str 指向的是字符串的第 0 个字符；我们通常将第 0  个字符的地址称为字符串的首地址。字符串中每个字符的类型都是char，所以 str 的类型也必须是char *。

//输出字符串：使用%s输出整个字符串，使用*或[ ]获取单个字符
#include <stdio.h>
#include <string.h>
int main(){
	char *str = "www.baidu.com";
	int len = strlen(str), i;
	//直接输出字符串
	printf("%s\n", str);

	//使用*(str+i)
	for (i = 0; i < len; i++){
		printf("%c",*(str+i));
	}
	printf("\n");

	//使用str[i]
	for (i = 0; i < len; i++){
		printf("%c", str[i]);
	}
	printf("\n");

	return 0;
}
//运行结果：
www.baidu.com
www.baidu.com
www.baidu.com

       字符数组&&字符串常量

       在编程中如果只涉及到对字符串的读取，那么字符数组和字符串常量都能满足需求；如果有写入（修改）操作，那么只能使用字符数组，不能使用字符串常量。

       获取用户输入的字符串就是一个典型的写入操作，只能使用字符数组，不能使用字符串常量，请看下面的代码：

#include <stdio.h>
int main(){
	char str[30];
	gets(str);
	printf("%s\n", str);

	return 0;
}
//运行结果：
www.baidu.com
www.baidu.com

       总结：C语言有两种表示字符串的方法，一种是字符数组，另一种是字符串常量，它们在内存中的存储位置不同，使得字符数组可以读取和修改，而字符串常量只能读取不能修改。

五、数组灵活多变的访问形式

#include <stdio.h>
int main(){
	char str[20] = "www.baidu.com";
	char *s1 = str;
	char *s2 = str + 4;
	char c1 = str[4];
	char c2 = *str;
	char c3 = *(str + 4);
	char c4 = *str + 2;
	char c5 = (str + 1)[5];

	int num1 = *str + 2;
	long num2 = (long)str;
	long num3 = (long)(str + 2);

	printf("s1=%s\n", s1);
	printf("s2=%s\n", s2);
	printf("c1=%c\n", c1);
	printf("c2=%c\n", c2);
	printf("c3=%c\n", c3);
	printf("c4=%c\n", c4);
	printf("c5=%c\n", c5);
	printf("num1=%d\n", num1);
	printf("num2=%ld\n", num2);
	printf("num3=%ld\n", num3);

	return 0;
}
//运行结果：
s1=www.baidu.com
s2=baidu.com
c1=b
c2=w
c3=b
c4=y
c5=i
num1=121
num2=17824436
num3=17824438
//解析：
(1) str既是数组名称，也是一个指向字符的指针；指针可以参加运算，指针加1相当于数组下标加1。
    printf() 输出字符串时，要求给定一个起始地址，并从这个地址开始输出，直到遇见NUL(\0)停止。s1 为字符串str第1个字符的地址，s2 为第4个字符的地址，所以 printf() 的结果分别为 www.baidu.com 和 baidu.com。
(2) 数组元素的访问形式可以看做 address[offset]，address 为起始地址，offset 为偏移量，所以：
c1 = str[4] 表示以地址 str 为起点，向后偏移4个字符，为b；
    str表示第0个字符的地址，*str表示第0个字符，即c2=w；因为指针可以参加运算，所以 str+4 表示第4个字符的地址，c3 = *(str+4) 表示第4个字符，即b。
    字符与整数运算时，先转换为整数（字符对应的ASCII码）。对于c4，*str为字符w(同c2)，w对应的ASCII为119，所以c4=119+2=121，转化为字符对应为y。
    c5 = (str+1)[5] 表示以地址 str+1 为起点，向后偏移5个字符，等价于str[6]，为i。
(3) 字符与整数运算时，先转换为整数（字符对应的ASCII码）。对于 num1，*str+2 == w+2 == 119+2 == 121，即num1为121；num2和num3分别为字符串str的首地址和第2个元素的地址。


六、指针变量作为函数参数

       在C语言中，函数的参数不仅可以是整数、小数、字符等具体的数据，还可以是指向它们的指针。用指针变量作函数参数可以将函数外部的地址传递到函数内部，使得在函数内部可以操作函数外部的数据，并且这些数据不会随着函数的结束而被销毁。

//使用指针变量作参数交换两个变量的值
#include <stdio.h>
void swap(int *p1, int *p2){
	int temp;//临时变量
	temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main(){
	int a = 10, b = 20;
	swap(&a, &b);
	printf("a=%d,b=%d\n",a,b);
	return 0;
}
//运行效果：a=20,b=10
//解析：调用 swap() 函数时，将变量 a、b 的地址分别赋值给 p1、p2，这样 *p1、*p2 代表的就是变量 a、b 本身，交换 *p1、*p2 的值也就是交换 a、b 的值。函数运行结束后虽然会将 p1、p2 销毁，但它对外部 a、b 造成的影响是“持久化”的，不会随着函数的结束而“恢复原样”。

七、指针作为函数返回值

       C语言允许函数的返回值是一个指针(地址），我们将这样的函数称为指针函数。

//定义函数 strlong()，用来返回两个字符串中较长的一个
#include <stdio.h>
#include <string.h>

char *strlong(char *str1, char *str2){
	if (strlen(str1) >= strlen(str2)){
		return str1;
	}
	else{
		return str2;
	}
}

int main(){
	char str1[30], str2[30], *str;
	gets(str1);
	gets(str2);
	str = strlong(str1, str2);
	printf("Longer string:%s\n", str);

	return 0;
}
//运行结果：
www.baidu.com
www.ali.com
Longer string:www.baidu.com

       用指针作为函数返回值时需要注意的一点是，函数运行结束后会销毁在它内部定义的所有局部数据，包括局部变量、局部数组和形式参数，函数返回的指针请尽量不要指向这些数据，C语言没有任何机制来保证这些数据会一直有效，它们在后续使用过程中可能会引发运行时错误。

八、二级指针(指向指针的指针）

       指针可以指向一份普通类型的数据，例如 int、double、char 等，也可以指向一份指针类型的数据，例如 int *、double *、char * 等。如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指针的指针。

      假设有一个 int 类型的变量 a，p1是指向 a 的指针变量，p2 又是指向 p1 的指针变量，它们的关系如下图所示：



       指针变量也是一种变量，也会占用存储空间，也可以使用 &获取它的地址。C语言不限制指针的级数，每增加一级指针，在定义指针变量时就得增加一个星号 *。p1 是一级指针，指向普通类型的数据，定义时有一个 *；p2 是二级指针，指向一级指针 p1，定义时有两个*。将这种关系转换为C语言代码：

int a =100;
int *p1 = &a;
int **p2 = &p1;
//如果我们希望再定义一个三级指针 p3，让它指向 p2，那么可以这样写：
int ***p3 = &p2;
//四级指针也是类似的道理：
int ****p4 = &p3;

       想要获取指针指向的数据时，一级指针加一个*，二级指针加两个*，三级指针加三个*，以此类推，请看代码：

#include <stdio.h>
int main(){
	int a = 100;
	int *p1 = &a;
	int **p2 = &p1;
	int ***p3 = &p2;

	printf("%d,%d,%d,%d\n",a,*p1,**p2,***p3);
	printf("&p2=%#X,p3=%#X\n", &p2, p3);
	printf("&p1=%#X,p2=%#X,*p3=%#X\n", &p1, p2, *p3);
	printf("&a=%#X,p1=%#X,*p2=%#X,**p3=%#X\n", &a, p1, *p2, **p3);
	return 0;
}
//运行结果：
100,100,100,100
&p2=0X75FB70,p3=0X75FB70
&p1=0X75FB7C,p2=0X75FB7C,*p3=0X75FB7C
&a=0X75FB88,p1=0X75FB88,*p2=0X75FB88,**p3=0X75FB88
//解析：以三级指针 p3 为例来分析上面的代码。***p3等价于*(*(*p3))。*p3 得到的是 p2 的值，也即 p1 的地址；*(*p3) 得到的是 p1 的值，也即 a 的地址；经过三次“取值”操作后，*(*(*p3)) 得到的才是 a 的值。


       假设 a、p1、p2、p3 的地址分别是 0X00A0、0X1000、0X2000、0X3000，它们之间的关系可以用下图来描述(方框里面是变量本身的值，方框下面是变量的地址。)：



九、空指针NULL与void指针

       1.空指针NULL

       一个指针变量可以指向计算机中的任何一块内存，不管该内存有没有被分配，也不管该内存有没有使用权限，只要把地址给它，它就可以指向，C 语言没有一种机制来保证指向的内存的正确性，程序员必须自己提高警惕。

       很多初学者会在无意间对没有初始化的指针进行操作，这是非常危险的，请看下面的例子：

#include <stdio.h>
int main(){
	char *str;
	gets(str);
	printf("%s\n", str);
	return 0;
}

       这段程序没有语法错误，但在Windows下编译连接会有警告，没有对指针进行初始化！我们知道，未初始化的局部变量的值是不确定的，C 语言并没有对此作出规定，不同的编译器有不同的实现，大家不要直接使用未初始化的局部变量。上面的代码中， str  就是一个未初始化的局部变量，它的值是不确定的，究竟指向哪块内存也是未知的，大多数情况下这块内存没有被分配或者没有读写权限，使用  gets()  函数向它里面写入数据显然是错误的。

       C语言中可以对没有初始化的指针赋值为 NULL ，例如：char *str = NULL;NULL  是 “ 零值、等于零 ” 的意思，在 C 语言中表示空指针。从表面上理解，空指针是不指向任何数据的指针，是无效指针，程序使用它不会产生效果。注意区分大小写，null  没有任何特殊含义，只是一个普通的标识符。

//给str赋值NULL
#include <stdio.h>
int main(){
	char *str = NULL;
	gets(str);
	printf("%s\n", str);
	return 0;
}
//貌似也会报错

       注意，C 语言没有规定 NULL 的指向，只是大部分标准库约定成俗地将 NULL 指向  0 ，所以不要将 NULL 和 0 等同起来，例如这种写法是不专业的：int *p = 0; 而应该坚持写为：int *p = NULL;

       注意 NULL 和 NUL 的区别：NULL 表示空指针，是一个宏定义，可以在代码中直接使用。而 NUL 表示字符串的结束标志  ’\0’ ，它是 ASCII 码表中的第  0  个字符。 NUL 没有在C语言中定义，仅仅是对  ’\0’ 的称呼，不能在代码中直接使用。

       2.void 指针

       void 用在函数定义中可以表示函数没有返回值或者没有形式参数，用在这里表示指针指向的数据的类型是未知的。也就是说，  void *  表示一个有效指针，它确实指向实实在在的数据，只是数据的类型尚未确定，在后续使用过程中一般要进行强制类型转换。C 语言动态内存分配函数  malloc()  的返回值就是  void * 类型，在使用时要进行强制类型转换。

#include <stdio.h>
#include <malloc.h>
int main(){
	//分配可以保存30个字符的内存，并把返回的指针转换为char *
	char *str = (char *)malloc(sizeof(char) * 30);
	gets(str);
	printf("%s\n",str);

	return 0;
}
//运行结果：
www.baidu.com
www.baidu.com

       注意：void * ，它不是空指针的意思，而是实实在在的指针，只是指针指向的内存中不知道保存的是什么类型的数据。

十、数组≠指针

       数组和指针不等价，数组是另外一种类型。数组和指针不等价的一个典型案例就是求数组的长度，这个时候只能使用数组名，不能使用数组指针：

#include <stdio.h>
int main(){
	int a[6] = { 0, 1, 2, 3, 4, 5 };
	int *p = a;
	int len_a = sizeof(a) / sizeof(int);
	int len_p = sizeof(p) / sizeof(int);
	printf("len_a=%d,len_p=%d\n",len_a,len_p);

	return 0;
}
//运行结果：len_a=6,len_p=1

       数组是一系列数据的集合，没有开始和结束标志，p 仅仅是一个指向 int 类型的指针，编译器不知道它指向的是一个整数还是一堆整数，对 p 使用 sizeof 求得的是指针变量本身的长度。也就是说，编译器并没有把 p 和数组关联起来，p 仅仅是一个指针变量，不管它指向哪里，sizeof 求得的永远是它本身所占用的字节数。

       1.数组在什么时候会转换为指针

       数组名的本意是表示一组数据的集合，它和普通变量一样，都用来指代一块内存，但在使用过程中，数组名有时候会转换为指向数据集合的指针（地址），而不是表示数据集合本身，这在前面的例子中已经被多次证实。

       数据集合包含了多份数据，直接使用一个集合没有明确的含义，将数组名转换为指向数组的指针后，可以很容易地访问其中的任何一份数据，使用时的语义更加明确。

       C语言标准规定，当数组名作为数组定义的标识符（也就是定义或声明数组时）、sizeof 或 & 的操作数时，它才表示整个数组本身，在其他的表达式中，数组名会被转换为指向第 0 个元素的指针（地址）。

       2.关于数组和指针可交换性的总结

       (1) 用 a[i] 这样的形式对数组进行访问总是会被编译器改写成（或者说解释为）像 *(a+i) 这样的指针形式。

       (2) 指针始终是指针，它绝不可以改写成数组。你可以用下标形式访问指针，一般都是指针作为函数参数时，而且你知道实际传递给函数的是一个数组。

       (3) 在特定的环境中，也就是数组作为函数形参，也只有这种情况，一个数组可以看做是一个指针。作为函数形参的数组始终会被编译器修改成指向数组第一个元素的指针。

       (4) 当希望向函数传递数组时，可以把函数参数定义为数组形式（可以指定长度也可以不指定长度），也可以定义为指针。不管哪种形式，在函数内部都要作为指针变量对待。

十一、C语言指针数组（每个元素都是指针）

       注意区别： 

       数组指针：指的是指针指向的是一个数组； 

       指针数组：表示的是数组的每个元素都是指针。

       如果一个数组中的所有元素保存的都是指针，那么我们就称它为指针数组。指针数组的定义形式一般为： 

dataType *arrayName[length]; 其中，[ ]的优先级高于*，该定义形式应该理解为： 
dataType *(arrayName[length]); 括号里面说明arrayName是一个数组，包含了length个元素，括号外面说明每个元素的类型为dataType *。

       除了每个元素的数据类型不同，指针数组和普通数组在其他方面都是一样的，下面是一个简单的例子：

include <stdio.h>
int main(){
    int a = 16, b = 932, c = 100;
    //定义一个指针数组
    int *arr[3] = {&a, &b, &c};//也可以不指定长度，直接写作 int *parr[]
    //定义一个指向指针数组的指针
    int **parr = arr;
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));

    return 0;
}
//运行结果：
16, 932, 100
16, 932, 100
//解析：
1. arr 是一个指针数组，它包含了 3 个元素，每个元素都是一个指针，在定义 arr 的同时，我们使用变量 a、b、c 的地址对它进行了初始化，这和普通数组是多么地类似。
2. parr 是指向数组 arr 的指针，确切地说是指向 arr 第 0 个元素的指针，它的定义形式应该理解为int (*parr)，括号中的表示 parr 是一个指针，括号外面的int 表示 parr 指向的数据的类型。arr 第 0 个元素的类型为 int ，所以在定义 parr 时要加两个 *。
3. 第一个 printf() 语句中，arr[i] 表示获取第 i 个元素的值，该元素是一个指针，还需要在前面增加一个 * 才能取得它指向的数据，也即 *arr[i] 的形式。
4. 第二个 printf() 语句中，parr+i 表示第 i 个元素的地址，(parr+i) 表示获取第 i 个元素的值（该元素是一个指针），*(parr+i) 表示获取第 i 个元素指向的数据。


       指针数组还可以和字符串数组结合使用，请看下面的例子：

#include <stdio.h>
int main(){
    char *str[3] = {
        "google.com",
        "hello world",
        "C Language"
    };
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
}
//运行结果：
google.com
hello world
C Language
//需要注意的是，字符数组 str 中存放的是字符串的首地址，不是字符串本身，字符串本身位于其他的内存区域，和字符数组是分开的。也只有当指针数组中每个元素的类型都是char *时，才能像上面那样给指针数组赋值，其他类型不行。
//为了便于理解，可以将上面的字符串数组改成下面的形式，它们都是等价的。
#include <stdio.h>
int main(){
	char *str0 = "google.com";
	char *str1 = "hello world";
	char *str2 = "C Language";
	char *str[3] = { str0, str1, str2 };
	printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
	return 0;
}
//运行结果：
google.com
hello world
C Language

       指针数组和二维数组指针的区别

       指针数组和二维数组指针在定义时非常相似，只是括号的位置不同：

       int *(p1[5]); //指针数组，可以去掉括号直接写作 int *p1[5];

       int (*p2)[5]; //二维数组指针，不能去掉括号

十二、函数指针（指向函数的指针）

       一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址，这和数组名非常类似。我们可以把函数的这个首地址（或称入口地址）赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。

       函数指针的定义形式为：

returnType (*pointerName)(param list);
其中，returnType 为函数返回值类型，pointerNmae 为指针名称，param list 为函数参数列表。参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。
注意( )的优先级高于*，第一个括号不能省略，如果写作returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为returnType *。

//用指针来实现对函数的调用
#include <stdio.h>
//返回两个数中较大的一个
int max(int a, int b){
    return a>b ? a : b;
}
int main(){
    int x, y, maxval;
    //定义函数指针
    int (*pmax)(int, int) = max;  //也可以写作int (*pmax)(int a, int b)
    printf("Input two numbers:");
    scanf("%d %d", &x, &y);
    maxval = (*pmax)(x, y);
    printf("Max value: %d\n", maxval);
    return 0;
}
//运行结果：
Input two numbers:10 30
Max value: 30
//解析：第 13 行代码对函数进行了调用。pmax 是一个函数指针，在前面加 * 就表示对它指向的函数进行调用。注意( )的优先级高于*，第一个括号不能省略。


十三、总结

       指针（Pointer）就是内存的地址，C语言允许用一个变量来存放指针，这种变量称为指针变量。指针变量可以存放基本类型数据的地址，也可以存放数组、函数以及其他指针变量的地址。

       程序在运行过程中需要的是数据和指令的地址，变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符：在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址；程序被编译和链接后，这些名字都会消失，取而代之的是它们对应的地址。



       (1) 指针变量可以进行加减运算，例如p++、p+i、p-=i。指针变量的加减运算并不是简单的加上或减去一个整数，而是跟指针指向的数据类型有关。

       (2) 给指针变量赋值时，要将一份数据的地址赋给它，不能直接赋给一个整数，例如int *p = 1000;是没有意义的，使用过程中一般会导致程序崩溃。

       (3) 使用指针变量之前一定要初始化，否则就不能确定指针指向哪里，如果它指向的内存没有使用权限，程序就崩溃了。对于暂时没有指向的指针，建议赋值NULL。

       (4) 两个指针变量可以相减。如果两个指针变量指向同一个数组中的某个元素，那么相减的结果就是两个指针之间相差的元素个数。

       (5) 数组也是有类型的，数组名的本意是表示一组类型相同的数据。在定义数组时，或者和 sizeof、& 运算符一起使用时数组名才表示整个数组，表达式中的数组名会被转换为一个指向数组的指针。

 

 

 

参考文献：C语言中文网

前言
函数指针和指针函数，在学习 C 语言的时候遇到这两个东西简直头疼，当然还有更头疼的，比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等，描述越长其定义就越复杂，当然理解起来就越难，特别是刚开始学习这门语言的童鞋，估计碰到这些东西就已经要崩溃了，然后好不容易死记硬背下来应付考试或者面试，然后过了几天发现，又是根本不会用，也不知道该在哪些地方用，这就尴尬了。

今天这里只讲两个相对简单的，其实上面说那些太复杂的东西也真的很少用，即便是用了理解起来很麻烦，所以莫不如先深刻理解这两个比较容易的，并且项目中比较常用到。
正文
先来看看两者的定义以及说明。
指针函数
定义
指针函数，简单的来说，就是一个返回指针的函数，其本质是一个函数，而该函数的返回值是一个指针。

声明格式为：*类型标识符 函数名(参数表)
这似乎并不难理解，再进一步描述一下。

看看下面这个函数声明：
int fun(int x,int y);

这种函数应该都很熟悉，其实就是一个函数，然后返回值是一个 int 类型，是一个数值。

接着看下面这个函数声明：
int *fun(int x,int y);

这和上面那个函数唯一的区别就是在函数名前面多了一个*号，而这个函数就是一个指针函数。其返回值是一个 int 类型的指针，是一个地址。
这样描述应该很容易理解了，所谓的指针函数也没什么特别的，和普通函数对比不过就是其返回了一个指针（即地址值）而已。
指针函数的写法
int *fun(int x,int y);
int * fun(int x,int y)；
int* fun(int x,int y);

这个写法看个人习惯，其实如果*靠近返回值类型的话可能更容易理解其定义。
示例
（由于本人习惯于 Qt 中进行开发，所以这里为了方便，示例是在 Qt 工程中写的，其语法是一样的，只是输出方式不同）

来看一个非常简单的示例：
typedef struct _Data{
    int a;
    int b;
}Data;

//指针函数
Data* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //调用指针函数
    Data * myData = f(4,5);
    qDebug() << "f(4,5) = " << myData->a << myData->b;

    return a.exec();
}


输出如下：
f(4,5) =  4 5

注意：在调用指针函数时，需要一个同类型的指针来接收其函数的返回值。

不过也可以将其返回值定义为 void*类型，在调用的时候强制转换返回值为自己想要的类型，如下：
//指针函数
void* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

调用：
Data * myData = static_cast<Data*>(f(4,5));

其输出结果是一样的，不过不建议这么使用，因为强制转换可能会带来风险。
函数指针
定义
函数指针，其本质是一个指针变量，该指针指向这个函数。总结来说，函数指针就是指向函数的指针。

声明格式：类型说明符 (*函数名)   (参数)

如下：
int (*fun)(int x,int y);

函数指针是需要把一个函数的地址赋值给它，有两种写法：
fun = &Function；
fun = Function;

取地址运算符&不是必需的，因为一个函数标识符就表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
调用函数指针的方式也有两种：
x = (*fun)();
x = fun();

两种方式均可，其中第二种看上去和普通的函数调用没啥区别，如果可以的话，建议使用第一种，因为可以清楚的指明这是通过指针的方式来调用函数。当然，也要看个人习惯，如果理解其定义，随便怎么用都行啦。
示例
int add(int x,int y){
    return x+y;
}
int sub(int x,int y){
    return x-y;
}
//函数指针
int (*fun)(int x,int y);

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //第一种写法
    fun = add;
    qDebug() << "(*fun)(1,2) = " << (*fun)(1,2) ;
	//第二种写法
    fun = &sub;
    qDebug() << "(*fun)(5,3) = " << (*fun)(5,3)  << fun(5,3)；

    return a.exec();
}


输出如下：
(*fun)(1,2) =  3
(*fun)(5,2) =  2 2

上面说到的几种赋值和调用方式我都分别使用了，其输出结果是一样的。
二者区别
通过以上的介绍，应该都能清楚的理解其二者的定义。那么简单的总结下二者的区别：
定义不同
指针函数本质是一个函数，其返回值为指针。

函数指针本质是一个指针，其指向一个函数。
写法不同
指针函数：int* fun(int x,int y);

函数指针：int (*fun)(int x,int y);

可以简单粗暴的理解为，指针函数的*是属于数据类型的，而函数指针的星号是属于函数名的。

再简单一点，可以这样辨别两者：函数名带括号的就是函数指针，否则就是指针函数。
用法不同
上面已经写了详细示例，这里就不在啰嗦了。
总而言之，这两个东西很容易搞混淆，一定要深入理解其两者定义和区别，避免犯错。
另外，本文都是针对普通函数指针进行介绍，如果是C++非静态成员函数指针，其用法会有一些区别，在另外一篇博客中单独介绍，文章在这里

目录

 前言:复杂类型说明

一、细说指针

1.指针的类型

2.指针所指向的类型

3.指针的值----或者叫指针所指向的内存区或地址

4 指针本身所占据的内存区

二、指针的算术运算

三、运算符&和*

四、指针表达式

五、数组和指针的关系

六、指针和结构类型的关系

七、指针和函数的关系

八、指针类型转换

九、指针的安全问题

转载于 ： https://backend.blog.csdn.net/article/details/6040863

 前言:复杂类型说明

    要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧:

 

 

int p; //这是一个普通的整型变量  
	
int *p; //首先从P 处开始,先与*结合,所以说明P 是一个指针,然后再与int 结合,说明指针所指向的内容的类型为int 型.所以P是一个返回整型数据的指针  
	
int p[3]; //首先从P 处开始,先与[]结合,说明P 是一个数组,然后与int 结合,说明数组里的元素是整型的,所以P 是一个由整型数据组成的数组  
	
int *p[3]; //首先从P 处开始,先与[]结合,因为其优先级比*高,所以P 是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与int 结合,说明指针所指向的内容的类型是整型的,所以P 是一个由返回整型数据的指针所组成的数组  
	
int (*p)[3]; //首先从P 处开始,先与*结合,说明P 是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以P 是一个指向由整型数据组成的数组的指针  
	
int **p; //首先从P 开始,先与*结合,说是P 是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与int 结合,说明该指针所指向的元素是整型数据.由于二级指针以及更高级的指针极少用在复杂的类型中,所以后面更复杂的类型我们就不考虑多级指针了,最多只考虑一级指针.  
	
int p(int); //从P 处起,先与()结合,说明P 是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数,然后再与外面的int 结合,说明函数的返回值是一个整型数据  
	
Int (*p)(int); //从P 处开始,先与指针结合,说明P 是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int 结合,说明函数有一个int 型的参数,再与最外层的int 结合,说明函数的返回类型是整型,所以P 是一个指向有一个整型参数且返回类型为整型的函数的指针  
	
int *(*p(int))[3]; //可以先跳过,不看这个类型,过于复杂从P 开始,先与()结合,说明P 是一个函数,然后进入()里面,与int 结合,说明函数有一个整型变量参数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一个数组,然后再与*结合,说明数组里的元素是指针,然后再与int 结合,说明指针指向的内容是整型数据.所以P 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数.  
说到这里也就差不多了,我们的任务也就这么多,理解了这几个类型,其它的类型对我们来说也是小菜了,不过我们一般不会用太复杂的类型,那样会大大减小程序的可读性,请慎用,这上面的几种类型已经足够我们用了.

 

 

一、细说指针

指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型、指针所指向的类型、指针的值或者叫指针所指向的内存区、指针本身所占据的内存区。让我们分别说明。

先声明几个指针放着做例子：
例一：

 

 

 

 

(1)int*ptr;  
	
(2)char*ptr;  
	
(3)int**ptr;  
	
(4)int(*ptr)[3];  
	
(5)int*(*ptr)[4];  
 

1.指针的类型

从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：
(1)int*ptr;//指针的类型是int*
(2)char*ptr;//指针的类型是char*
(3)int**ptr;//指针的类型是int**
(4)int(*ptr)[3];//指针的类型是int(*)[3]
(5)int*(*ptr)[4];//指针的类型是int*(*)[4]
怎么样？找出指针的类型的方法是不是很简单？

 

 

 

2.指针所指向的类型

当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。
从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。例如：
(1)int*ptr; //指针所指向的类型是int
(2)char*ptr; //指针所指向的的类型是char
(3)int**ptr; //指针所指向的的类型是int*
(4)int(*ptr)[3]; //指针所指向的的类型是int()[3]
(5)int*(*ptr)[4]; //指针所指向的的类型是int*()[4]

在指针的算术运算中，指针所指向的类型有很大的作用。
指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C 越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。

 

 

 

3.指针的值----或者叫指针所指向的内存区或地址

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32 位程序里，所有类型的指针的值都是一个32 位整数，因为32 位程序里内存地址全都是32 位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为si zeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX 为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。
以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？（重点注意）

 

 

 

4 指针本身所占据的内存区

指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32 位平台里，指针本身占据了4 个字节的长度。指针本身占据的内存这个概念在判断一个指针表达式（后面会解释）是否是左值时很有用。

 

二、指针的算术运算

指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的，以单元为单位。例如：
例二：

 

 

char a[20];  
	
int *ptr=(int *)a; //强制类型转换并不会改变a 的类型  
	
ptr++;  
在上例中，指针ptr 的类型是int*,它指向的类型是int，它被初始化为指向整型变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针ptr 的值加上了sizeof(int)，在32 位程序中，是被加上了4，因为在32 位程序中，int 占4 个字节。由于地址是用字节做单位的，故ptr 所指向的地址由原来的变量a 的地址向高地址方向增加了4 个字节。由于char 类型的长度是一个字节，所以，原来ptr 是指向数组a 的第0 号单元开始的四个字节，此时指向了数组a 中从第4 号单元开始的四个字节。我们可以用一个指针和一个循环来遍历一个数组，看例子：
例三：

 

 

int array[20]={0};  
	
int *ptr=array;  
	
for(i=0;i<20;i++)  
	
{  
	
    (*ptr)++;  
	
    ptr++；  
	
}  
这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1 个单元，所以每次循环都能访问数组的下一个单元。

 

再看例子：
例四：

 

 

char a[20]="You_are_a_girl";  
	
int *ptr=(int *)a;  
	
ptr+=5;  
在这个例子中，ptr 被加上了5，编译器是这样处理的：将指针ptr 的值加上5 乘sizeof(int)，在32 位程序中就是加上了5 乘4=20。由于地址的单位是字节，故现在的ptr 所指向的地址比起加5 后的ptr 所指向的地址来说，向高地址方向移动了20 个字节。

在这个例子中，没加5 前的ptr 指向数组a 的第0 号单元开始的四个字节，加5 后，ptr 已经指向了数组a 的合法范围之外了。虽然这种情况在应用上会出问题，但在语法上却是可以的。这也体现出了指针的灵活性。如果上例中，ptr 是被减去5，那么处理过程大同小异，只不过ptr 的值是被减去5 乘sizeof(int)，新的ptr 指向的地址将比原来的ptr 所指向的地址向低地址方向移动了20 个字节。

下面请允许我再举一个例子:(一个误区)

例五:

 

 

#include<stdio.h>  
	
int main()  
	
{  
	
    char a[20]=" You_are_a_girl";  
	
    char *p=a;  
	
    char **ptr=&p;  
	
    //printf("p=%d\n",p);  
	
    //printf("ptr=%d\n",ptr);  
	
    //printf("*ptr=%d\n",*ptr);  
	
    printf("**ptr=%c\n",**ptr);  
	
    ptr++;  
	
    //printf("ptr=%d\n",ptr);  
	
    //printf("*ptr=%d\n",*ptr);  
	
    printf("**ptr=%c\n",**ptr);  
	
}  
误区一、输出答案为Y 和o
误解:ptr 是一个char 的二级指针,当执行ptr++;时,会使指针加一个sizeof(char),所以输出如上结果,这个可能只是少部分人的结果.
误区二、输出答案为Y 和a误解:ptr 指向的是一个char *类型,当执行ptr++;时,会使指针加一个sizeof(char *)(有可能会有人认为这个值为1,那就会得到误区一的答案,这个值应该是4,参考前面内容), 即&p+4; 那进行一次取值运算不就指向数组中的第五个元素了吗?那输出的结果不就是数组中第五个元素了吗?答案是否定的.
正解: ptr 的类型是char **,指向的类型是一个char *类型,该指向的地址就是p的地址(&p),当执行ptr++;时,会使指针加一个sizeof(char*),即&p+4;那*(&p+4)指向哪呢,这个你去问上帝吧,或者他会告诉你在哪?所以最后的输出会是一个随机的值,或许是一个非法操作.
总结一下:
一个指针ptrold 加(减)一个整数n 后，结果是一个新的指针ptrnew，ptrnew 的类型和ptrold 的类型相同，ptrnew 所指向的类型和ptrold所指向的类型也相同。ptrnew 的值将比ptrold 的值增加(减少)了n 乘sizeof(ptrold 所指向的类型)个字节。就是说，ptrnew 所指向的内存区将比ptrold 所指向的内存区向高(低)地址方向移动了n 乘sizeof(ptrold 所指向的类型)个字节。指针和指针进行加减：两个指针不能进行加法运算，这是非法操作，因为进行加法后，得到的结果指向一个不知所向的地方，而且毫无意义。两个指针可以进行减法操作，但必须类型相同，一般用在数组方面，不多说了。

 

 

 

三、运算符&和*

这里&是取地址运算符，*是间接运算符。
&a 的运算结果是一个指针，指针的类型是a 的类型加个*，指针所指向的类型是a 的类型，指针所指向的地址嘛，那就是a 的地址。
*p 的运算结果就五花八门了。总之*p 的结果是p 所指向的东西，这个东西有这些特点：它的类型是p 指向的类型，它所占用的地址是p所指向的地址。
例六：

 

 

int a=12; int b; int *p; int **ptr;  
	
p=&a; //&a 的结果是一个指针，类型是int*，指向的类型是  
	
//int，指向的地址是a 的地址。  
	
*p=24; //*p 的结果，在这里它的类型是int，它所占用的地址是  
	
//p 所指向的地址，显然，*p 就是变量a。  
	
ptr=&p; //&p 的结果是个指针，该指针的类型是p 的类型加个*，  
	
//在这里是int **。该指针所指向的类型是p 的类型，这  
	
//里是int*。该指针所指向的地址就是指针p 自己的地址。  
	
*ptr=&b; //*ptr 是个指针，&b 的结果也是个指针，且这两个指针  
	
//的类型和所指向的类型是一样的，所以用&b 来给*ptr 赋  
	
//值就是毫无问题的了。  
	
**ptr=34; //*ptr 的结果是ptr 所指向的东西，在这里是一个指针，  
	
//对这个指针再做一次*运算，结果是一个int 类型的变量。  
 

四、指针表达式

一个表达式的结果如果是一个指针，那么这个表达式就叫指针表式。
下面是一些指针表达式的例子：
例七：

 

 

int a,b;  
	
int array[10];  
	
int *pa;  
	
pa=&a; //&a 是一个指针表达式。  
	
Int **ptr=&pa; //&pa 也是一个指针表达式。  
	
*ptr=&b; //*ptr 和&b 都是指针表达式。  
	
pa=array;  
	
pa++; //这也是指针表达式。  

例八：

 

 

char *arr[20];  
	
char **parr=arr; //如果把arr 看作指针的话，arr 也是指针表达式  
	
char *str;  
	
str=*parr; //*parr 是指针表达式  
	
str=*(parr+1); //*(parr+1)是指针表达式  
	
str=*(parr+2); //*(parr+2)是指针表达式  
由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。
好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。在例七中，&a 不是一个左值，因为它还没有占据明确的内存。*ptr 是一个左值，因为*ptr 这个指针已经占据了内存，其实*ptr 就是指针pa，既然pa 已经在内存中有了自己的位置，那么*ptr 当然也有了自己的位置。

 

 

 

五、数组和指针的关系

数组的数组名其实可以看作一个指针。看下例：
例九：

 

 

int array[10]={0,1,2,3,4,5,6,7,8,9},value;  
	
value=array[0]; //也可写成：value=*array;  
	
value=array[3]; //也可写成：value=*(array+3);  
	
value=array[4]; //也可写成：value=*(array+4);  
上例中，一般而言数组名array 代表数组本身，类型是int[10]，但如果把array 看做指针的话，它指向数组的第0 个单元，类型是int* 所指向的类型是数组单元的类型即int。因此*array 等于0 就一点也不奇怪了。同理，array+3 是一个指向数组第3 个单元的指针，所以*(array+3)等于3。其它依此类推。
例十：

 

 

char *str[3]={  
	
    "Hello,thisisasample!",  
	
    "Hi,goodmorning.",  
	
    "Helloworld"  
	
};  
	
char s[80]；  
	
strcpy(s,str[0]); //也可写成strcpy(s,*str);  
	
strcpy(s,str[1]); //也可写成strcpy(s,*(str+1));  
	
strcpy(s,str[2]); //也可写成strcpy(s,*(str+2));  
上例中，str 是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str 当作一个指针的话，它指向数组的第0 号单元，它的类型是char **，它指向的类型是char *。
*str 也是一个指针，它的类型是char *，它所指向的类型是char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址，即'H'的地址。注意:字符串相当于是一个数组,在内存中以数组的形式储存,只不过字符串是一个数组常量,内容不可改变,且只能是右值.如果看成指针的话,他即是常量指针,也是指针常量.
str+1 也是一个指针，它指向数组的第1 号单元，它的类型是char**，它指向的类型是char*。
*(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向"Hi,goodmorning."的第一个字符'H'

下面总结一下数组的数组名(数组中储存的也是数组)的问题:
声明了一个数组TYPE array[n]，则数组名称array 就有了两重含义：
第一，它代表整个数组，它的类型是TYPE[n]；
第二，它是一个常量指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0 号单元，该指针自己占有单独的内存区，注意它和数组第0 号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。在不同的表达式中数组名array 可以扮演不同的角色。在表达式sizeof(array)中，数组名array 代表数组本身，故这时sizeof 函数测出的是整个数组的大小。
在表达式*array 中，array 扮演的是指针，因此这个表达式的结果就是数组第0 号单元的值。sizeof(*array)测出的是数组单元的大小。
表达式array+n（其中n=0，1，2，.....）中，array 扮演的是指针，故array+n 的结果是一个指针，它的类型是TYPE *，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。在32 位程序中结果是4
例十一:

 

 

int array[10];  
	
int (*ptr)[10];  
	
ptr=&array;：  
上例中ptr 是一个指针，它的类型是int(*)[10]，他指向的类型是int[10] ，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array 代表数组本身。
本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？
答案是前者。例如：
int(*ptr)[10];
则在32 位程序中，有：
sizeof(int(*)[10])==4
sizeof(int[10])==40
sizeof(ptr)==4
实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。

 

 

 

六、指针和结构类型的关系

可以声明一个指向结构类型对象的指针。
例十二：

 

 

struct MyStruct  
	
{  
	
    int a;  
	
    int b;  
	
    int c;  
	
};  
	
struct MyStruct ss={20,30,40};  
	
//声明了结构对象ss，并把ss 的成员初始化为20，30 和40。  
	
struct MyStruct *ptr=&ss;  
	
//声明了一个指向结构对象ss 的指针。它的类型是  
	
//MyStruct *,它指向的类型是MyStruct。  
	
int *pstr=(int*)&ss;  
	
//声明了一个指向结构对象ss 的指针。但是pstr 和  
	
//它被指向的类型ptr 是不同的。  
请问怎样通过指针ptr 来访问ss 的三个成员变量？

答案：
ptr->a; //指向运算符，或者可以这们(*ptr).a,建议使用前者
ptr->b;

 

ptr->c;

 

 

又请问怎样通过指针pstr 来访问ss 的三个成员变量？

答案：
*pstr； //访问了ss 的成员a。
*(pstr+1); //访问了ss 的成员b。
*(pstr+2) //访问了ss 的成员c。

 

虽然我在我的MSVC++6.0 上调式过上述代码，但是要知道，这样使用pstr 来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数组的各个单元: (将结构体换成数组)

 

 

例十三：

 

 

int array[3]={35,56,37};  
	
int *pa=array;  
	
//通过指针pa 访问数组array 的三个单元的方法是：  
	
*pa; //访问了第0 号单元  
	
*(pa+1); //访问了第1 号单元  
	
*(pa+2); //访问了第2 号单元  
从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。
所有的C/C++编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。
所以，在例十二中，即使*pstr 访问到了结构对象ss 的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a 和成员b 之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错的方法。
不过指针访问结构成员的正确方法应该是象例十二中使用指针ptr 的方法。

 

 

 

七、指针和函数的关系

可以把一个指针声明成为一个指向函数的指针。
int fun1(char *,int);
int (*pfun1)(char *,int);
pfun1=fun1;
int a=(*pfun1)("abcdefg",7); //通过函数指针调用函数。
可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。
例十四：

 

 

int fun(char *);  
	
inta;  
	
char str[]="abcdefghijklmn";  
	
a=fun(str);  
	
int fun(char *s)  
	
{  
	
    int num=0;  
	
    for(int i=0;;)  
	
    {  
	
        num+=*s;s++;  
	
    }  
	
    return num;  
	
}  
这个例子中的函数fun 统计一个字符串中各个字符的ASCII 码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s 后，实际是把str 的值传递给了s，s 所指向的地址就和str 所指向的地址一致，但是str 和s 各自占用各自的存储空间。在函数体内对s 进行自加1 运算，并不意味着同时对str 进行了自加1 运算。

 

 

 

八、指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是一样的。
例十五：

 

 

float f=12.3;  
	
float *fptr=&f;  
	
int *p;  
在上面的例子中，假如我们想让指针p 指向实数f，应该怎么办？
是用下面的语句吗？
p=&f;
不对。因为指针p 的类型是int *，它指向的类型是int。表达式&f 的结果是一个指针，指针的类型是float *,它指向的类型是float。
两者不一致，直接赋值的方法是不行的。至少在我的MSVC++6.0 上，对指针的赋值语句要求赋值号两边的类型一致，所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，需要进行"强制类型转换"：
p=(int*)&f;
如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP *TYPE， 那么语法格式是： (TYPE *)p；
这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE *，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。
而原来的指针p 的一切属性都没有被修改。（切记）
一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，必须保证类型一致，否则需要强制转换
例十六：

 

 

void fun(char*);  
	
int a=125,b;  
	
fun((char*)&a);  
	
void fun(char*s)  
	
{  
	
    charc;  
	
    c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;  
	
    c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;  
	
}  
注意这是一个32 位程序，故int 类型占了四个字节，char 类型占一个字节。函数fun 的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用语句中，实参&a 的结果是一个指针，它的类型是int *，它指向的类型是int。形参这个指针的类型是char *，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须进行一次从int *类型到char *类型的转换。
结合这个例子，我们可以这样来
想象编译器进行转换的过程：编译器先构造一个临时指针char *temp，然后执行temp=(char *)&a，最后再把temp 的值传递给s。所以最后的结果是：s 的类型是char *,它指向的类型是char，它指向的地址就是a 的首地址。
我们已经知道，指针的值就是指针指向的地址，在32 位程序中，指针的值其实是一个32 位整数。
那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句：

 

 

unsigned int a;  
	
TYPE *ptr; //TYPE 是int，char 或结构类型等等类型。  
	
a=20345686;  
	
ptr=20345686; //我们的目的是要使指针ptr 指向地址20345686  
	
  
	
ptr=a; //我们的目的是要使指针ptr 指向地址20345686  
	
//编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法：  
	
unsigned int a;  
	
TYPE *ptr; //TYPE 是int，char 或结构类型等等类型。  
	
a=N //N 必须代表一个合法的地址；  
	
ptr=(TYPE*)a； //呵呵，这就可以了。  

严格说来这里的(TYPE *)和指针类型转换中的(TYPE *)还不一样。这里的(TYPE*)的意思是把无符号整数a 的值当作一个地址来看待。上面强调了a 的值必须代表一个合法的地址，否则的话，在你使用ptr 的时候，就会出现非法操作错误。想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针：
例十七：

 

 

int a=123,b;  
	
int *ptr=&a;  
	
char *str;  
	
b=(int)ptr; //把指针ptr 的值当作一个整数取出来。  
	
str=(char*)b; //把这个整数的值当作一个地址赋给指针str。  
现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。

 

 

 

九、指针的安全问题

看下面的例子：
例十八：

 

 

char s='a';  
	
int *ptr;  
	
ptr=(int *)&s;  
	
*ptr=1298；  
指针ptr 是一个int *类型的指针，它指向的类型是int。它指向的地址就是s 的首地址。在32 位程序中，s 占一个字节，int 类型占四个字节。最后一条语句不但改变了s 所占的一个字节，还把和s 相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。
让我们再来看一例：
例十九：

 

 

char a;  
	
int *ptr=&a;  
	
ptr++;  
	
*ptr=115;  
该例子完全可以通过编译，并能执行。但是看到没有？第3 句对指针ptr 进行自加1 运算后，ptr 指向了和整形变量a 相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。
而第4 句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。
在指针的强制类型转换：ptr1=(TYPE *)ptr2 中，如果sizeof(ptr2的类型)大于sizeof(ptr1 的类型)，那么在使用指针ptr1 来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2 的类型) 小于sizeof(ptr1 的类型)，那么在使用指针ptr1 来访问ptr2 所指向的存储区时是不安全的。至于为什么，读者结合例十八来想一想，应该会明白的。