1、绪论

指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作

计算机中所有的数据都必须放在内存中，不同类型的数据占用的字节数不一样，例如 int 占用 4 个字节，char 占用 1 个字节。为了正确地访问这些数据，必须为每个字节都编上号码，就像门牌号、身份证号一样，每个字节的编号是唯一的，根据编号可以准确地找到某个字节。

在计算机中, 所有的数据都是存放在存储器中的, 不同的数据类型占有的内存空间的大小各不相同。内存是以字节为单位的连续编址空间, 每一个字节单元对应着一个唯一的编号, 这个编号被称为内存单元的地址。比如: int类型占两个字节, char类型占1个字节等。内存为变量分配存储空间的首个字节单元的地址, 称之为该变量的地址。地址用来标识每一个存储单元, 方便用户对存储单元中的数据进行正确的访问。在高级语言中地址形象地称为指针， CPU 访问内存时需要的是地址，而不是变量名和函数名！变量名和函数名只是地址的一种助记符，当源文件被编译和链接成可执行程序后，它们都会被替换成地址。编译和链接过程的一项重要任务就是找到这些名称所对应的地址。

需要注意的是变量名和函数名为我们提供了方便，让我们在编写代码的过程中可以使用易于阅读和理解的英文字符串，不用直接面对二进制地址，那场景简直让人崩溃。虽然变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符，但在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址。

指针相对于一个内存单元来说，指的是单元的地址，该单元的内容里面存放的是数据。在C语言中，允许用指针变量来存放指针，因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。

2、指针的定义与使用

变量的指针与指针变量：

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

变量的指针就是变量的存储地址，指针变量就是存储指针的变量。指针变量是存放一个变量地址的变量，不同于其他类型变量，它是专门用来存放内存地址的，也称为地址变量。定义指针变量的一般形式为：类型说明符 * 变量名 * 类型说明符表示指针变量所指向变量的数据类型；* 表示这是一个指针变量；变量名表示定义的指针变量名，其值是一个地址，例如：char * p1;表示p1是一个指针变量，它的值是某个字符变量的地址

//定义指针变量与定义普通变量非常类似，不过要在变量名前面加星号*，格式为：
int *fp;//*表示这是一个指针变量，fp是一个指向int数据类型的指针
float *a,*b; //表示a和b都是指针变量，都指向一个为float数据类型的指针

指针变量的使用：

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

//赋值
int a = 100;//定义了一个a的整形变量
int *p_a = &a;//将一个int类型的指针p_a，p_a指向了a（也叫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;//P1指向a的地址
char *p2 = &c;//p2指向c的地址
//修改指针变量的值
p1 = &b;//将p1改变指向为b
p2 = &d;//将p2改变指向为a

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

//注意
不允许把一个数赋予指针变量
int *p;
p = &a;
*p = 100;//这样是错误的

或者：
int b=200;
int *a;
a=b; //这样也错误，因为没有加上取地址符&

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

#include <stdio.h>
int main(){
    int a = 66;//定义整形变量
    int *p = &a; //定义int的指针变量并指向a变量的地址
    printf("%d, %d\n", a, *p);  //两种方式都可以输出a的值
    return 0;
}

//假设 a 的地址是 0X1000，p 指向 a 后，p 本身的值也会变为 0X1000，*p 表示获取地址 0X1000 上的数据，
也即变量 a 的值。所以从运行结果看，*p 和 a 是等价的。

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

//程序被编译和链接后，a、p 被替换成相应的地址。使用 *p 的话，要先通过地址 0XF0A0 取得变量 p 本身的值，
这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据

也就是说，使用指针是间接获取数据，使用变量名是直接获取数据，前者比后者的代价要高。

可以用指针来改变被指向那个变量的值如：

#include <stdio.h>
int main(void){
    int a = 1, b = 66, c = 2;//定义普通变量
    int *p = &a;  //定义指针变量并指向a的地址
    *p = b;  //通过指针变量将a的值改变了 （因为在这里，*p指向了a 就等于*p和a身处同一个内存空间了，
                                                                所以对*p修改 就相当于对a修改）
    c = *p;  //把指针p的值的赋值给了C (根据前面说的，相当于将a赋值给了C)
    printf("%d, %d, %d, %d\n", a, b, c, *p);//所以他们的值都是同一个了
    return 0;
}
*在不同的场景下有不同的作用：*可以用在指针变量的定义中，
表明这是一个指针变量，以和普通变量区分开；使用指针变量时在前面加*表示获取指针指向的数据，或者说表示的是指针指向的数据本身。

也就是说，定义指针变量时的*和使用指针变量时的*意义完全不同。以下面的语句为例：

int *p = &a;//这里表示指向a的地址
*p = 100;  //这里表示获取指针所指向的数据

其他一些骚操作：

int x, y, *px = &x, *py = &y;
y = *px + 5;  //表示把x的内容加5并赋给y，*px+5相当于(*px)+5
y = ++*px;  //px的内容加上1之后赋给y，++*px相当于++(*px)
y = *px++;  //相当于y=(*px)++
py = px;  //把一个指针的值赋给另一个指针

关于“&”和“*”

“&”和“ * ”都是右结合的。假设有变量 x = 10，则*&x 的含义是，先获取变量 x 的地址，再获取地址中的内容。因为“&”和“ * ”互为逆运算，所以 x = *&x。

假设有一个 int 类型的变量 a， pa 是指向a的指针，那么*&a和&*pa分别是什么意思呢？

*&a可以理解为*(&a)，&a表示取变量 a 的地址（等价于 pa），*(&a)表示取这个地址上的数据（等价 * pa），绕来绕去，又回到了原点，*&a仍然等价于 a。

&*pa可以理解为&(*pa)，*pa表示取得 pa 指向的数据（等价于 a），&(*pa)表示数据的地址（等价于 &a），所以&*pa等价于 pa。

野指针与空指针

空指针是说,这个指针没有指向一块有意义的内存,比如说:char* k; 这里这个k就叫空指针.我们并未让它指向任意点. 又或者char* k = NULL; 这里这个k也叫空指针,因为它指向NULL 也就是0,注意是整数0,不是'\0' 一个空指针我们也无法对它进行取内容操作,空指针只有在真正指向了一块有意义的内存后,我们才能对它取内容.也就是说要这样 k = "hello world!"; 这时k就不是空指针了.

对于空指针值，一般的文档中倾向于用 NULL 表示，而没有直接说成 0。但是我们应该清楚：对于指针类型来说，返回 NULL 和返回 0 是完全等价的，因为 NULL 和 0 都表示 “null pointer”（空指针）。一句话，空指针是什么，就是一个被赋值为0的指针，在没有被具体初始化之前，其值为0.（百度解释）

如：

int *a;//定义一个指针a=NULL;//让这个指针指向空a =0;//这样也是让一个指针指向空的方式

注意：void* 这不叫空指针,这叫无确切类型指针.这个指针指向一块内存,却没有告诉程序该用何种方式来解释这片内存.所以这种类型的指针不能直接进行取内容的操作.必须先转成别的类型的指针才可以把内容解释出来. 还有'\0',这也不是空指针所指的内容. '\0'是表示一个字符串的结尾而已,并不是NULL的意思 void*因为是表示不知道要指向什么东西的指针，计算时于char相同（但不相通）

野指针不同于空指针，空指针是指一个指针的值为null，而野指针的值并不为null，野指针会指向一段实际的内存，只是它指向哪里我们并不知情，或者是它所指向的内存空间已经被释放，所以在实际使用的过程中，我们并不能通过指针判空去识别一个指针是否为野指针。避免野指针只能靠我们自己养成良好的编程习惯

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。（百度解释）

下面说说哪些情况下会产生野指针，以及怎样避免。

1、指针变量的值未被初始化：声明一个指针的时候，没有显示的对其进行初始化，那么该指针所指向的地址空间是乱指一气的。如果指针声明在全局数据区，那么未初始化的指针缺省为空，如果指针声明在栈区，那么该指针会随意指向一个地址空间。所以良好的编程习惯就是在声明指针的时候就对其进行初始化，如果暂时不知道该初始化成什么值，就先把指针置空。

int main(void){
int *a;//野指针

if(a!=NULL){
....
}

/*
int *a; 
a=NULL/0;  正确的引用
*/
}

2、指针所指向的地址空间已经被free或delete：在堆上malloc或者new出来的地址空间，如果已经free或delete，那么此时堆上的内存已经被释放，但是指向该内存的指针如果没有人为的修改过，那么指针还会继续指向这段堆上已经被释放的内存，这时还通过该指针去访问堆上的内存，就会造成不可预知的结果，给程序带来隐患，所以良好的编程习惯是：内存被free或delete后，指向该内存的指针马上置空。

void func()
{
    int *ptr = new int[5];
    delete [ ]ptr;
    // 执行完delete后，ptr野指针

	//还应该这样做：ptr=NULL; 正确

}

3、指针操作超越了作用域，如果在一个程序块中让一个指针指向那个块中的某个变量，但是那个变量只是在块中有效，出了那个程序块，此变量就无效了，此时指向它的指针也就变成了野指针

void func()
{
    int *ptr = nullptr;
    {
        int a = 10;
        ptr = &a;
    } // a的作用域到此结束

    int b = *ptr;    // ptr指向的a，但是a已经被回收，所以ptr变成野指针
	//还应该这样做：ptr=NULL; 正确
}

所以使用指针时应当注意”规避“：初始化时置 NULL，释放时置 NULL

3、指针的运算

C 指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。递增递减加减，两个指针相减

#include<stdio.h>
int main(void) {
	int a=10; 
	int *pa = &a,*pA=&a;

	double b = 22.2;
	double *pb = &b;

	char c = 'C';
	char *pc = &c;

	//最初的值
	printf("1- %#x %#x %#x \n", &a, &b, &c);//%#x表示 转换成十六进制带格式输出地址,
                                                 //效果为在输出前加0x
	printf("2- %#x %#x %#x \n", pa, pb, pc);

	//指针加法
	pa += 2; pb += 2; pc += 2;
	printf("3- %#x %#x %#x \n", pa, pb, pc);

	//指针减法
	pa -= 2; pb -= 2; pc -= 2;
	printf("4- %#x %#x %#x\n", pa, pb, pc);

	//指针的比较
	if (pa == pA) {
		printf("5=%d\n", *pA);

	}
	else {
		printf("6=%d\n", *pa);
	}

	return 0;

}

//从运算结果可以看出：pa、pb、pc 每次加 1，它们的地址分别增加 4、8、1，正好是 int、double、char 类型的长度；
                            减 2 时，地址分别减少 8、16、2，正好是 int、double、char 类型长度的 2 倍。

/*简单的概括就是：
指针的每一次递增，它其实会指向下一个元素的存储单元。
指针的每一次递减，它都会指向前一个元素的存储单元。
指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。


指针变量除了可以参与加减运算，还可以参与比较运算。当对指针变量进行比较运算时，比较的是指针变量本身的值，也就是数据的地址。
如果地址相等，那么两个指针就指向同一份数据，否则就指向不同的数据。当然还有其他逻辑运算符

上面的代码（第一个例子）在比较 pa 和 pA 的值时，pa 已经指向了 a 的上一份数据，所以它们不相等。而 a 的上一份数据又不知道是什么，
所以会导致 printf() 输出一个没有意义的数，这正好印证了上面的观点，不要对指向普通变量的指针进行加减运算

注意：不能对指针变量进行乘法、除法、取余等其他运算，除了会发生语法错误，也没有实际的含义。

#include<stdio.h>//指针的加减法其实上的地址上的移动
int main(void) {
	char a[] = {2,3,4,5,6};
	char *p = &a[0];
	char *p1 = &a[10];

	printf("p1-p=%d\n", p1 - p);
	printf("p=%p\n", p);
	printf("p1=%p\n", p1);

	//这里如果运算为大于零，就是真 输出 0
	//如果运算为小于零，就是假 输出   -1
	int *t = a[0];
	int *k = a[3];
	printf("* %d\n", t-k);

	int b[] = { 1,2,3,4,5,6 };
	int *q = &b[0];
	int *q1 = &b[6];
	printf("q1-q=%d\n", q1 - q);
	printf("%p\n", q1);
	printf("%p\n", q);

	return 0;
}

常见的指针运算：
*（++p）: 先移动指针，取下一个单元的值
*（p++）: 先取出当前单元的值，再移动指针
（ * p）++ : 先取出当前单元的值，再使当前单元的值加1 （指针不移动）
++（ * p） : 先使当前单元的值加1，再取出当前单元的值（指针不移动）

指针的类型转换： int *p=&i; void *q=(void * )p; 这并没有改变p所指向的变量的类型，而是让后人用不同的眼光通过p看它所指的变量意思是：这里的p我不再当你是int了，认为你就是个void类型的

注意由于优先级的问题 *p++和 * （p++）是等价的

取地址符 &补充：获得变量的地址，它的操作必须是变量， int i,printf("%x",&i); 取得i的地址并输出。 int i,printf("%p",&i); 取得i的地址并输出。地址的大小是否于int相同取决于编译器

注意使用指针的时候的类型，无论指向什么类型，所有的指针的大小都是一样的，因为都是地址，但是指向不同类型的指针是不能相互赋值的，这是为了避免用错指针。

4、字符串与指针、数组与指针

定义数组时，要给出数组名和数组长度，数组名可以认为是一个指针，它指向数组的第 0 个元素。在C语言中，我们将第 0 个元素的地址称为数组的首地址，数组名的本意是表示整个数组，也就是表示多份数据的集合，但在使用过程中经常会转换为指向数组第 0 个元素的指针，所以上面使用了“认为”一词，表示数组名和数组首地址并不总是等价。

#include<stdio.h>
int main(void) {

	int a[] = {1,2,3,4,5,6};
	int line = sizeof(a) / sizeof(a[0]);//计算数组长度
	int i;

	for (i = 0; i < line; i++) {

		printf("%d  ", *(a + i));  //这里的*(a + i)相当于a[i]
	}
	return 0;
}

我们使用的*(a+i)这个表达式，a 是数组名，指向数组的第 0 个元素，表示数组首地址，
 a+i 指向数组的第 i 个元素，*(a+i) 表示取第 i 个元素的数据，它等价于 a[i]。

我们也可以定义一个指向数组的指针，例如：

int a[]={1,2,3,4,5,6};
int *p=a;

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

    注意  ：a 本身就是一个指针”这种表述并不准确，严格来说应该是“a 被转换成了一个指针，
            如果一个指针指向了数组，我们就称它为数组指针（Array Pointer）

数组指针指向的是数组中的一个具体元素，而不是整个数组，所以数组指针的类型和数组元素的类型有关，上面的例子中，p 指向的数组元素是 int 类型，所以 p 的类型必须也是int *。反过来想，p 并不知道它指向的是一个数组，p 只知道它指向的是一个整数，究竟如何使用 p 取决于程序员的编码。

数组在内存中只是数组元素的简单排列，没有开始和结束标志，在求数组的长度时不能使用指针p来sizeof(p) / sizeof(int)这样来求，因为 p 只是一个指向 int 类型的指针，编译器并不知道它指向的到底是一个整数还是一系列整数（数组），所以 sizeof(p) 求得的是 p 这个指针变量本身所占用的字节数，而不是整个数组占用的字节数。如果不知道数组的长度，那么就无法遍历整个数组

引入数组指针后，我们就有两种方案来访问数组元素了，一种是使用下标，另外一种是使用指针： 1) 使用下标也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针，那么也可以使用 p[i] 来访问数组元素，它等价于 arr[i]。

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

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

//利用自增来遍历数组
#include<stdio.h>
int main(void) {

	int a[] = { 1,2,3,4,5,6 };
	int line = sizeof(a) / sizeof(a[0]);
	int i;
	int *p = a;//指针p指向数组首地址

	for (i = 0; i < line; i++) {

		printf("地址a[%d]：%p\n ",i,p);
		printf("值a[%d]:%d \n", i, *p);

			//指针自增移动
			p++;
	}

	return 0;
} 


/*自减也是同样的效果
  递增递减需要注意的：
 *p++；表示取出p所指向的那个数据来，完事后顺便把p移动到下一个地址位置去 ， * 的优先级虽然高，但是没
有++高，这个是常用于数组之类的连续空间中，

	注意：

	//int b[ ] = a;   不可以做
	//int *p = a;    可以做
	//	b = a;       不可以做
	//int b[ ] = -- > int * const b;  因为const表示b常量的数不能改变

另外： const int a[ ]={1,2,3,4,5,6}; 数组变量已经是const的指针了，这里的const表示数组的每个单元都是const int 所以必须通过初始化进行赋值。

数组变量是特殊的指针，数组变量本身表达地址，所以 int a[10];int *p=a //不用取地址值，但是数组的单元表达的是变量，需要用&取地址， int b==&a[0]; [ ]运算符可以对数组做，也可以对指针做：p[0]=a[0];

C语言中没有特定的字符串类型，我们通常是将字符串放在一个字符数组中，所以字符数组归根结底还是一个数组，上节讲到的关于指针和数组的规则同样也适用于字符数组。更改上面的代码，使用指针的方式来输出字符串：

#include<stdio.h>
#include<stdlib.h>

int main(void) {
	char s[] = "hello world";
	char *p = s;
	int len = strlen(s);//获得字符串长度函数
	int i;
	//使用指针遍历字符串输出
	for (i = 0; i < len; i++) {
		printf("%c", *(p + i));
	}
	printf("\n");

	//使用数组的方式遍历输出
	for (i = 0; i < len; i++) {
		printf("%c", p[i]);
	}
	printf("\n");

	//使用指针的形式输出
	for (i = 0; i < len; i++) {
		printf("%c", *(s + i));
	}

	printf("\n");
	return 0;

}

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

char *str;
str = "hello world";

/*字符串指针指向的是一个字符串,str是一个char类型的指针变量，
指向字符串"hello world"，指针变量str存放的是这个字符串的首地址。
所以输出的是一个字符串，应改写成printf(“%s\n”,str);

字符串中的所有字符在内存中是连续排列的，str 指向的是字符串(字符数组)的第 0 个字符；我们通常将第 0 个字符的地址称为字符串的首地址。字符串中每个字符的类型都是char，所以 str 的类型也必须是char *。

这一切看起来和字符数组是多么地相似，它们都可以使用%s输出整个字符串，都可以使用*或[ ]获取单个字符，这两种方式的区别如下：
它们最根本的区别是在内存中的存储区域不一样，字符数组存储在全局数据区或栈区，第二种形式的字符串存储在常量区。全局数据区和栈区的字符串（也包括其他数据）有读取和写入的权限，而常量区的字符串（也包括其他数据）只有读取权限，没有写入权限。内存权限的不同导致的一个明显结果就是，字符数组在定义后可以读取和修改每个字符，而对于第二种形式的字符串，一旦被定义后就只能读取不能修改，任何对它的赋值都是错误的。

我们将第二种形式的字符串称为字符串常量，意思很明显，常量只能读取不能写入：

    char *str = "Hello World!";//这里是字符常量是指针
    str = "I love C!";  //正确  让常量字符串指针重新指向一个字符串
    str[3] = 'P';  //错误   这个是想通过一个字符常量指针让一个字符数组赋值

这段代码能够正常编译和链接，但在运行时会出现段错误（Segment Fault）或者写入位置错误。第2行代码是正确的，可以更改指针变量本身的指向；第3行代码是错误的，不能修改字符串中的字符。

那么究竟是使用字符数组还是字符串常量指针呢？在编程过程中如果只涉及到对字符串的读取，那么字符数组和字符串常量都能够满足要求；如果有写入（修改）操作，那么只能使用字符数组，不能使用字符串常量。

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

5、指针做函数参数，指针做函数返回类型

有时候我们可以使用函数的返回值来回传数据，在简单的情况下是可以的，但是如果返回值有其它用途（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。所以要引用上指针来传递

指针做函数参数：

在C语言中，函数的参数不仅可以是整数、小数、字符等具体的数据，还可以是指向它们的指针。用指针变量作函数参数可以将函数外部的地址传递到函数内部，使得在函数内部可以访问到函数外部的数据，并且这些数据不会随着函数的结束而被销毁。像数组、字符串、动态分配的内存等都是一系列数据的集合，没有办法通过一个参数全部传入函数内部，只能传递它们的指针，在函数内部通过指针来影响这些数据集合。有的时候，对于整数、小数、字符等基本类型数据的操作也必须要借助指针，一个典型的例子就是交换两个变量的值：

#include <stdio.h>
void swap(int a, int b){
    int temp;  //临时变量
    temp = a;
    a = b;
    b = temp;
}
int main(){
    int a = 66, b = 99;
    swap(a, b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

/*
    从结果可以看出，a、b 的值并没有发生改变，交换失败。
这是因为 swap() 函数内部的 a、b 和 main() 函数内部的 a、b 是不同的变量，
占用不同的内存，它们除了名字一样，没有其他任何关系，swap() 交换的是它内部 a、b 的值，
不会影响它外部（main() 内部） a、b 的值。他们会随着函数段的结束而失去了作用域

利用指针：

#include <stdio.h>
void swap(int *p1, int *p2){//这里接收到的是a和b的地址
    int temp;  
    temp = *p1;//利用地址将值做修改
    *p1 = *p2;
    *p2 = temp;
}
int main(){
    int a = 66, b = 99;
    swap(&a, &b);//这里将a和b的地址获取传入
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

//函数运行结束后虽然会将 p1、p2 销毁，但它对外部 a、b 造成的影响是“持久化”的，
不会随着函数的结束而“恢复原样”。因为我们对它做的是进入到地址的修改

用数组做函数参数：

如果一个函数按值传递数组，则必须分配足够的空间来存储原数组的副本，然后把原数组的所有数组拷贝到新的数组中去，如果把数组的地址传递给函数，让函数来直接处理原来数组则效率要高。但是传递地址的时候，总会导致一些问题，C通常安值传递数据，因为这样做可以保证数据的完整性，如果函数使用的是原始的数组的副本，就不会发生修改原始数据，但是，处理数组的函数通常都需要使用原始数据，因此这样的函数可以修改原数组，有时，这正是我们需要的：void add(double a[ ],int n,int b); 调用此函数，将可以将原来数组的值进行修改，也可以说是函数通过指针，直接将原数组做修改了

数组是一系列数据的集合，无法通过参数将它们一次性传递到函数内部，如果希望在函数内部操作数组，必须传递数组指针。下面的例子定义了一个函数 max()，用来查找数组中值最大的元素：

#include<stdio.h>
int max(int len, int a[]);//声明  注意这里的a[ ] 里边没有任何东西，其实也可以放东西也可以不放的

/*实际上这种形式的数组定义都是假象，不管是int a[100]还是int a[]都不会创建一个数组出来，编译器也不会为它们分配内存，实际的数组是不存在的，它们最终还是会转换为int *intArr这样的指针。这就意味着，两种形式都不能将数组的所有元素“一股脑”传递进来，大家还得规规矩矩使用数组指针。*/
//真正传递的数组可以有少于或多于 100 个的元素。
int main(void) {

	int n;
	int a[100];
	int i;

	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", a+i);//给数组里边的值初始化
	}				//这个a的原型是 int *a 
					//所以这里可以使用 &a[i] 或者 a+i
	printf("max=%d", max(n,&a));
	return 0;
}

int max(int len, int a[]) {//定义
	int t = a[0];
	int i;

	for (i = 1; i < len; i++) {//依次比较
		if (t < a[i]) {
			t = a[i];
		}

	}

	return t;//返回max
}

注意 不管使用哪种方式传递数组，都不能在函数内部求得数组长度，因为 intArr 仅仅是一个指针，
     而不是真正的数组，所以必须要额外增加一个参数来传递数组长度。

//有时候，因为把数组传入函数时传递的是地址，所以那个函数内部可以修改数组的值，
  为了保护数组的值不被函数修改破坏，可以设置参数为const:
int sum (const int a[ ],int b);

C语言为什么不允许直接传递数组的所有元素，而必须传递数组指针呢？参数的传递本质上是一次赋值的过程，赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。

对于像 int 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。而数组是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行内存拷贝有可能是一个漫长的过程，会严重拖慢程序的效率，为了防止技艺不佳的程序员写出低效的代码，C语言没有从语法上支持数据集合的直接赋值。

指针的函数返回类型：程序编译后,每个函数都有执行第一条指令的地址即首地址,称[函数指针。函数指针即指向函数的指针变量,要间接调用函数可以使用指针变量来实现。

int (*pf)(int, int);

通过将pf与括号中的“*”强制组合组合在一起,表示定义的pf是一个指针,然后与下面的“()”再次组合,表示的是该指针指向一个函数,括号里表示为int类型的参数,最后与前面的int组合,此处int表示该函数的返回值。因此,pf是指向函数的指针,该函数的返回值为int。函数指针与返回指针的函数的含义大不相同。函数指针本身是一个指向函数的指针。指针函数本身是一个返回值为指针的函数。

#include<stdio.h>
#include<stdlib.h>

char *strs(char *strl1, char *strl2);//声明一个char*类型的指针函数
int main(void) {

	char str1[50];//定义字符串
	char str2[50];
	char *str;//定义字符指针

	gets(str1);//输入
	gets(str2);

	str = strs(str1, str2);
	printf("%s", str);

	return 0;

}
char *strs(char *strl1, char *strl2) {

	if (strlen(strl1) > strlen(strl2)) {//比较长度   谁长返回谁
		return strl1;
	}
	else {
		return strl2;
	}
}

用指针作为函数返回值时需要注意的一点是，函数运行结束后会销毁在它内部定义的所有局部数据，包括局部变量、局部数组和形式参数，函数返回的指针请尽量不要指向这些数据，C语言没有任何机制来保证这些数据会一直有效，它们在后续使用过程中可能会引发运行时错误 , 但是，这里所谓的销毁并不是将局部数据所占用的内存全部抹掉，而是程序放弃对它的使用权限，弃之不理，后面的代码可以随意使用这块内存 , 如果使用及时也能够得到正确的数据，如果有其它函数被调用就会覆盖这块内存，得到的数据就失去了意义。而覆盖它的究竟是一份什么样的数据我们无从推断（一般是一个没有意义甚至有些怪异的值）。

#include <stdio.h>
int *func(){
    int n = 100;
    return &n;
}
int main(){
    int *p = func(), n;
    n = *p;
    printf("value = %d\n", n);//因为前面没有覆盖，所以还是能得到之前的值
    return 0;
}

            ******与下面比较：******

#include <stdio.h>
int *func(){
    int n = 100;
    return &n;
}
int main(){
    int *p = func(), n;
    printf("c.biancheng.net\n");//这里会覆盖掉
    n = *p;
    printf("value = %d\n", n);//所以输出的值会无从得知
    return 0;
}

还应该注意函数指针变量的调用：

分析函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或数组元素，而函数指针的移动是毫无意义的。函数调用中“（* 指针变量名）”的两边的括号不可少，其中的“*”不应该理解为求值运算，在此处只是一种表示符号。要把“z= * pomax(x,y);”改成“z=(*pomax)(x,y);”。

6、二级指针 (多级指针)

指针变量作为一个变量也有自己的存储地址，而指向指针变量的存储地址就被称为指针的指针，即二级指针。依次叠加，就形成了多级指针。指针可以指向一份普通类型的数据，例如 int、double、char 等，也可以指向一份指针类型的数据，例如 int *、double *、char * 等。如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指针的指针。,我们先看看二级指针，它们关系如下：

int a =100;//一个普通变量
int *p1 = &a;//一个一级指针p1指向a变量的地址
int **p2 = &p1;//一个二级指针p2指向p1指针的地址
//	p2   ->   p1   ->   a
//	&p1       &a       100

/*规律：
一级指针 指向变量的地址
二级指针 指向一级指针的地址
三级指针 指向二级指针的地址
依次类推....

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

多级指针的话就是：

int ***p3 = &p2;//三级指针
int ****p4 = &p3;//四级指针
int *****p5 = &p4;//五级指针

//实际开发中会经常使用一级指针和二级指针，几乎用不到高级指针。

想要获取指针指向的数据时，一级指针加一个*，二级指针加两个*，三级指针加三个* 关系如下：

#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;
}
//以三级指针 p3 为例来分析上面的代码。***p3等价于*(*(*p3))。*p3 得到的是 p2 的值，
  也即 p1 的地址；*(*p3) 得到的是 p1 的值，也即 a 的地址；经过三次“取值”操作后，*(*(*p3)) 
  得到的才是 a 的值。

7、指针数组、指向函数的指针、指向二维数组的指针

指针数组：

指针变量和普通变量一样，也能组成数组,如果一个数组中的所有元素保存的都是指针，那么我们就称它为指针数组。指针数组的定义形式一般为：

数据类型 * 名字 [数组长度]；
这里注意 [ ]的优先级比 * 来得高
int *a [10];
这里说明a是一个数组，包含了10个元素，每个元素的类型为int *。

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

#include<stdio.h>
int main(void) {

	int a = 1;
	int b = 2;
	int c = 3;

	//定义一个指针的数组
	int *an[3] = { &a,&b,&c };//由于里边每一个元素都是指针，所以利用取地址符&，指向abc三个变量

	//这里定义一个指向指针数组的指针，由于数组已经是指针了，所以要用到二级指针
	int **p = an;//由于数组本身就是表示一个地址所以不用取地址符&

	printf("%d %d %d\n", *an[0], *an[1], *an[2]);
	printf("%d %d %d\n", **(p + 0) , **(p + 1), **(p + 2));

	return 0;
}

//arr 是一个指针数组，它包含了 3 个元素，每个元素都是一个指针，在定义 arr 的同时，
我们使用变量 a、b、c 的地址对它进行了初始化，这和普通数组是多么地类似。

    parr 是指向数组 arr 的指针，确切地说是指向 arr 第 0 个元素的指针，
它的定义形式应该理解为int *(*parr)，括号中的*表示 parr 是一个指针，
括号外面的int *表示 parr 指向的数据的类型。arr 第 0 个元素的类型为 int *，
所以在定义 parr 时要加两个 *。

指针数组还可以和字符串数组结合使用:

#include <stdio.h>
int main(){

    char *str[3] = {  //定义一个字符串数组 长度为3
        "c.biancheng.net",
        "C语言中文网",
        "C Language"
    };

    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);//依次输出每个字符串
    return 0;
}

指向函数的指针:

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

数据类型 *指针名 （数据类型 参数）；

数据为函数返回值类型，指针名称，括号里边为函数参数列表。参数列表中可以同时给出参数的类型和名称，
也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。

注意( )的优先级高于*，第一个括号不能省略，如果写作returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为returnType *

用指针来实现对函数的调用：

#include <stdio.h>

//返回两个数中较大的一个
int max(int a, int b){
    return a>b ? a : b;
}
int main(void){

    int x, y, maxval;
    //定义指向函数指针*pmax
    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;
}

 // maxval 对函数进行了调用。pmax 是一个函数指针，在前面加 * 就表示对它指向的函数进行调用。
   注意( )的优先级高于*，第一个括号不能省略。

指向二维数组的指针：

（复盘一下二维数组的知识）二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例：

int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

a就是像一个矩阵：
0   1   2   3
4   5   6   7
8   9  10  11

但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存：
【0】【1】【2】【3】【4】【5】【6】【7】【8】【9】【10】【11】

C语言中的二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。

C语言把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含 `a[0][0] 、a[0][1]、a[0][2]、a[0][3]。

为了更好的理解指针和二维数组的关系，我们先来定义一个指向 a 的指针变量 p：

int (*p)[4] = a;
//括号中的*表明 p 是一个指针，它指向一个数组，数组的类型为int [4]，
  这正是 a 所包含的每个一维数组的类型。

[ ]的优先级高于*，( )是必须要加的，如果赤裸裸地写作int *p[4]，那么应该理解为int *(p[4])，p 就成了一个指针数组，而不是二维数组指针。

对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关，p 指向的数据类型是int [4]，那么p+1就前进 4×4 = 16 个字节，p-1就后退 16 个字节，那么这正好是数组 a 所包含的每个一维数组的长度。也就是说，p+1会使得指针指向二维数组的下一行，p-1会使得指针指向数组的上一行。

按照上面的定义，我们来看看代码：

#include <stdio.h>
int main(void){

    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
    int (*p)[4] = a;

    printf ( "%d\n",  sizeof(*(p+1))  );//这里输出是16
    return 0;
}

*(p+1)+1表示第 1 行第 1 个元素的地址： *(p+1)单独使用时表示的是第 1 行数据，放在表达式中会被转换为第 1 行数据的首地址，也就是第 1 行第 0 个元素的地址，因为使用整行数据没有实际的含义，编译器遇到这种情况都会转换为指向该行第 0 个元素的指针；就像一维数组的名字，在定义时或者和 sizeof、& 一起使用时才表示整个数组，出现在表达式中就会被转换为指向数组第 0 个元素的指针。

*(*(p+1)+1) 表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据：**

规律：
a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)


#include<stdio.h>
int main(void) {
	int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
	int i, j;
	int(*p)[4] = a;//定义一个指向二维数组的指针p
					
	for (i = 0; i < 3; i++) {
		for (j = 0; j < 4; j++) {

			printf("%d ", *(*(p+i)+j));//利用二级指针就可以访问到i行j列的元素
		}			//*(p+i)：一维数组
		printf("\n");		//*(*(p+i)+j)  二维数组
	}

	return 0;

}

/*输出：
1 2 3 4
5 6 7 8
9 10 11 12


数组名 a 在表达式中也会被转换为和 p 等价的指针！

指针数组和二维数组指针在定义时非常相似，但是括号的位置不同所表示的意思也就天壤之别：

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

指针数组和二维数组指针有着本质上的区别：指针数组是一个数组，只是每个元素保存的都是指针，以上面的 p1 为例，在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针，它指向一个二维数组，以上面的 p2 为例，它占用 4 个字节的内存。

至于多维数组和二维数组没有本质的区别，但是复杂度倒是高了许多。一般不常用。

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

常见的的指针：

定义	含义
int *p;	p 可以指向 int 类型的数据，也可以指向类似 int arr[n] 的数组。
int **p;	p 为二级指针，指向 int * 类型的数据。
int *p[n];	p 为指针数组。[ ] 的优先级高于，所以应该理解为 int (p[n]);
int (*p)[n];	p 为二维数组指针。
int *p();	p 是一个函数，它的返回值类型为 int *。
int (*p)();	p 是一个函数指针，指向原型为 int func() 的函数。

1、指针变量可以进行四则运算。指针变量的加减运算并不是简单的加上或减去一个整数，而是跟指针指向的数据类型与地址有关。

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

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

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

指针的用法暂时就这些，C指针大法这些才是入门，后面持续补充..