---

一、指针的本质

 1.1指针的定义

    内存区域中的每字节都对应一个编号，这个编号就是“地址”。如果程序中定义了一个变量，那么在对程序进行编译时，系统就会给这个变量分配内存单元。
    按变量地址存取变量值的方式称为直接访问，如printf(“%d”,i)；另一种存取变量值的方式称为间接访问，即变量i的地址存放到另一个变量中。
指针变量是一种特殊的变量，它用来存放变量地址。
指针变量的定义格式如下：

基类型 *指针变量名;
int *i_pointer;

指针与指针变量是两个概念，一个变量的地址称为该变量的“指针”。
例如，地址2000是指针变量 i 的指针，如果有一个变量专门用来存放另一变量的地址（即指针），那么称它为“指针变量”。i_pointer就是一个指针变量。

 1.2取地址操作符与取值操作符

 取地址操作符为&，也称引用。通过使用它可以获取一个变量的地址值；
 取值操作符为*，也称解引用。通过使用它我们可以得到一个地址对应的数据 。
举个例子

输出：

注意
（1）指针变量前面的 * 表示该变量为指针型变量

float *pointer;

指针变量名是pointer，而不是 *pointer。

（2）在定义指针变量时必须指定其类型。只有整型变量的地址才能放到指向整型变量的指针变量中
举个例子

float a;
int *p;
p=&a;
//以上会出错，正确的如下
int a;
int *p;
p=&a;

错误实例如下：

（3）如果执行了语句

p=&a;

&* p的含义是什么呢？

  "&“和” * "两个运算符的优先级相同，但要按自右向左的方向结合。因此，&* p与&a相同，都表示变量a的地址，也就是p。

&a的含义是什么呢？
  首先进行&a运算，得到a的地址，在进行运算。*&a与a等价。

（4）C语言是一种自由形式的语言，很容易把 * 写在靠近类型的一侧。 int a,b,c的语句会使人们很自然地认为这条语句把所有三个变量声明为指向整型的指针，但事实上并非如此，“”实际上是*a的一部分，只对a标识符起作用，但其余两个变量只是普通的整型变量.要声明三个指针变量,正确的语句如下:

int *a,*b,*c;

二、指针的使用场景

 2.1指针的传递

指针的传递使用场景

#include <stdio.h>
#include <stdlib.h>
void change(int j)//j为形参
{
    j=5;
}
int main()
{
    int i=10;//i是局部变量
    printf("befor change i=%d\n",i);
    change(i);//函数调用时，把i称为形参
    printf("after change i=%d\n",i);
    system("pause");
    return 0;
}

 2.2指针的偏移

对指针的加减称为指针的偏移，加就是向后偏移，减就是向前偏移。
指针的偏移使用场景

#include <stdlib.h>
#include <stdio.h>
#define N 5
//指针的偏移
int main()
{
    int a[N]={1,2,3,4,5};
    int *p;//对一个指针变量进行取值，得到的类型是其基类型
    int i;
    p=a;	//保证等号两边的数值类型一致
    printf("*p=%d\n",*p);
    for(int i=0;i<5;i++)//正序输出
    {
        printf("%3d\n",*(p+i));
    }
    printf("\n---------\n");
    p=&a[4];//让p指向最后一个元素
    for(i=0;i<N;i++)//逆序输出
    {
    	printf("%3d",*(p-i));
    }
    printf("\n");
    system("pause");
    return 0;
}

注意偏移的长度是其基类型的长度，也就是偏移sizeof(int)
数组是特殊的，不能和整型变量，浮点型，字符型变量类比。
数组名  a 类型是数组，a里面存了一个值，是地址值，是数组的起始

 2.3指针与自增、自减运算符

指针的自增与自减

#include <stdio.h>
#include <stdlib.h>
//只有比后增优先级高的操作符，才会作为一个整体，如()、[]
int main()
{
	int a[3]={2,7,8};
	int *p;
	int j;
	p=a;
	j=*p++;//先把*p的值赋给j，然后对p加1,可写成j=*p;p++;
	//第一步，任何时候都是把后++去掉，第二步看优先级是否高于++
	printf("a[0]=%d,j=%d\n",a[0],j,*p);
	j=p[0]++;//先把p[0]赋给j，然后对p[0]加1
	printf("a[0]=%d,j=%d,*p=%d\n",a[0],j,*p);
	system("pause");
	return 0; 
} 

为什么第一次输出的是j=2,*p=7呢?
 首先，前面讲过当遇到后增操作符时，就要分两步来看。第一步是暂时忽略++操作，即 j=p，因为p指向数组的第一个元素，所以j=2。
那么第二步是对p进行++操作，因为操作符和++操作符的优先级相同，只有比++优先级高的操作符才会当一个整体。目前，用过比++操作符优先级高的操作符只有[]和()两个。
思考一下：
如果让a[0]为3，*p也为3，应如何修改？

 第二次输出为什么是j=7,p=8 呢?首先, p指向的是元素a[1]，对于 j=p[o]++，忽略++操作，也就是j=p[0]，所以j=7、接着是对p进行++操作还是对p[0进行++操作呢?显然，是对p[o]进行++操作，所以p等于8。
 后减操作符与后增操作符类似，因为编写习惯问题，我们很少使用前增和前减操作符。

 2.4指针与一维数组

一维数组名中存储的是数组的首地址。
 数组名c中存储的地址为Ox0015faf4，所以子函数change 中其实传入了一个地址.
 定义一个指针变量时，指针变量的类型要和数组的数据类型保持一致，通过取值操作，就可将“h”改为“H”，这种方法称为指针法．
 获取数组元素时，也可以通过取下标的方式来获取数组元素并进行修改，这种方法称为下标法。

#include <stdio.h>
#include <stdlib.h>
void change(char *d)
{
	*d='H';
	d[1]='E';
	*(d+2)='L';
}
//指针与一维数组
int main()
{
	char c[10]="hello";
	change(c);
	printf("%s\n",c);
} 

 2.5指针与动态内存申请

C语言的数组长度固定是因为其定义的整型、浮点型、字符型变量、数组变量都在栈空间中，而栈空间的大小在编译时是确定的，如果使用的空间大小不确定，那么就要使用堆空间。
栈是自动分配，堆可以理解为一个图书馆
动态内存申请

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
	int i;
	char *p;
	scanf("%d",&i);//输入要申请的空间大小
	p=(char*)malloc(i);//使用malloc动态申请堆空间
	strcpy(p,"malloc success";);
	puts(p);
	free(p);//free时必须使用malloc申请返回的指针值，不能进行任何偏移
	printf("free malloc\n");
	system("pause"); 
}

首先我们来看malloc函数。
 在执行#include <stdlib.h>void malloc(size_t size);时，需要给malloc传递的参数是一个整型变量，因为这里的size_t即为 int;**返回值为void类型的指针**, void类型的指针只能用来存储一个地址而不能进行偏移，因为malloc并不知道我们申请的空间用来存放什么类型的数据，所以确定要用来存储什么类型的数据后，都会将void强制转换为对应的类型.
 在上述代码中我们用来存储字符，所以将其强制转换为char*类型.

如图 所示，定义的整型变量i、指针变量p均在main函数的栈空间中，通过 malloc申请的空间会返回一个堆空间的首地址，我们把首地址存入变量p.知道了首地址，就可以通过strcpv函数往对应的空间存储字符数据

栈空间和堆空间的区别？
 栈时计算机系统提供的数据结构，计算机会在底层对栈提供支持；分配专门的寄存器存放栈的地址，压栈操作、出栈操作都有专门的指令执行。
 堆则是C/C++函数库提供的数据结构，例如为了分配一块内存，函数库会按照一定的算法在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能由于内存碎片太多），那么就有可能调用系统功能区增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后返回。
显然，堆得效率要比栈的效率低得多

&emsp；栈空间由系统自动管理，而堆空间的申请和释放需要自行管理，所以需要通过free函数释放堆空间。

#include <stdlib.h>
void free(void *ptr);

**解释：**其传入参数为void类型指针，任何指针均可自动转为void*类型指针，所以我们把p传递给free函数时，不需要强制类型转换。
 p的地址值必须是malloc当时返回的地址值，不能进行偏移，也就是malloc和free之间不能进行p++等改变量p的操作,原因是申请一段堆内存空间时，内核会帮我们记录的是起始地址和大小，所以释放时内核用对应的首地址进行匹配，匹配不上，进程就会崩溃。如果要偏移进而存储数据，那么可以定义两个指针变量解决。
栈空间与堆空间的差异

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//函数栈空间释放后，函数内的所有局部变量消失，函数执行完之后，它所占的栈空间也会释放掉
char*print_stack()
{
	char c[]="I am print_stack"；
	puts(c);
	return c; 
} 
//堆空间不会因函数之行结束而释放 
char *print_malloc()
{
	char*p;
	p=(char*)malloc(20);
	puts(p);
	return p;
}
int main()
{
	char*p;
	p=print_stack();//数据存放在栈空间，栈空间会随着函数的执行结束而释放
	puts(p);//打印异常，出现乱码
	p=print_malloc();//数据放在堆空间，堆空间不会随函数的结束而释放，只有free之后才可以释放，否则一直存在
	puts(p);
	system("pause"); 
}

问题：为什么第二次打印会有异常且每次执行打印的效果都不一样呢？
 原因是print_stack()函数中的字符串存放在栈空间中，函数执行结束后，栈空间会被释放，字符数组c的原有空间已被分配给其他函数使用，因此在调用print_stack()函数后，执行puts§就会出现打印乱码，而print_malloc()函数中的字符串存放在堆空间中，堆空间只有在执行free操作后才会释放，否则进程执行过程中会一直有效。

 2.6字符指针与字符数组的初始化

 字符指针可以初始化赋值一个字符串，字符数组初始化也可以赋值一个字符串。

字符指针与字符数组初始化

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

int main()
{
    char*p="hello";//把字符串型常量“hello”的首地址赋给p
    char c[10]="hello";//等价于strcpy(c,"hello")；
    c[0]='H';
    printf("c[0]=%c\n",c[0]);
    printf("p[0]=%c\n",p[0]);
    //p[0]='H';//不可以对常量区数据进行修改
    p="world";//将字符串world的地址赋给p
    //c=“world”；非法
    system("pause");
    return 0;
}

如上图所示，编译器编译时，将字符串常量存储在数据区中的常量区，这样做的好处是相同的字符串“hello”只会存储一次，常量区的含义是存储在此区域中的字符串本身是不可修改的，称为“字符串型常量”。
 hello存储在字符串型常量区，占用6字节，有自己的首地址，char *p=“hello”将字符串型常量hello的首地址赋给p。对于char c[10]=“hello”，字符数组c在栈空间有10字节大小的空间，这个初始化将字符串hello通过strcpy函数赋给字符数组c，因此我们可以将c[0]修改为"H",而p[0]得到的是常量区的空间，所以不可修改。
 p是一个指针变量，我们可以将字符串“world”的首地址重新赋给p。而数组名c本身存储的就是数组的首地址，是确定的，不可修改的，c等价于符号常量。因此，c=“world”编译不通。

三、二级指针

引言：
 一级指针的使用场景是传递与偏移，服务的对象是整型变量、浮点型变量、字符型变量等。而二级指针也是一种指针，其只服务于一级指针的传递与偏移。

 3.1二级指针的传递

#include <stdio.h>
#include <stdlib.h>
void change(int **p,int *pj)
{
    int i=5;
    *p=pj;
}
//想要在子函数中改变一个变量的值，必须把该变量的地址传进去
//要想在子函数中改变一个指针变量的值，必须把指针变量的地址传进去
int main()
{
    int i=10;
    int j=5;
    int *pi;
    int *pj;
    pi=&i;
    pj=&j;
    printf("i=%d,*pi=%d,*pj=%d\n",i,*pi,*pj);//等于10
    change(&pi,pj);
    printf("after change i=%d,*pi=%d,*pj=%d \n",i,*pi,*pj);
    system("pause");
    return 0;
}

解释：整型指针pi指向整型变量i，整形指针pj指向整型变量j。通过子函数change，我们想改变指针变量pi的值，让其指向j。由于c语言的函数调用是值传递，因此要想在change中改变变量pi的值，就必须把pi的地址传递给change。
 pi是一级指针，&pi的类型即为二级指针。