深入理解--指针

一、指针的概念

要知道指针的概念，要先了解变量在内存中如何存储的。在存储时，内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针（地址），就像酒店的门牌号一样。

可以把指针理解成地址

1.1、变量和地址

先写一段简单的代码

void main(){
    int x = 10, int y = 20;
}

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

x内部存储的内容是10，x的地址是6487552.

我们可以通过地址找到x这一块空间，对内部的内容进行修改。

二、变量的指针与指针变量

变量的指针就是变量的存储地址，指针变量就是存储指针的变量。

int x=10;x变量的地址是0X1234.     int* pi=&x；pi内容是0X1234。而pi的地址是另外的数字

2.1、指针变量的定义及使用

（1）指针变量的定义

指针变量的定义形式如：数据类型 *指针名;例如：

//分别定义了 int、float、char 类型的指针变量
int *x;
float *f;
char *ch;
如上面的定义，指针变量名为 x、f、ch。并不是*x、*f、*ch

为什么要分成不同的指针类型呢？不都是存储地址，地址的大小在32位机器下是4个字节。在64位机器下是8个字节。

解释：

地址+1之后又有区别

char类型+1会跳过1个字节的空间

int类型+1会跳过4个字节的空间

int* p和int *p在机器看来没有区别，但是int* p的写法不好（合法，但不规范，容易造成误导）

int* p1,p2;//p1是int类型的指针变量，而p2是int类型（p2不是指针！不是指针！）

规范的写法是int *p1,*p2;//这样两个变量的类型都是指针

（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。

2.2、指针变量的初始化

指针变量与其它变量一样，在定义时可以赋值，即初始化。也可以赋值“NULL”或“0”，如果赋值“0”，此时的“0”含义并不是数字“0”，而是 NULL 的字符码值。（一般会赋成NULL，而不是0，0容易产生误解）；

//利用取地址获取 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 运算，表示指针向前或向后移动一个单元（不同类型的指针，单元长度不同）。

例如：

int x=10;//x的地址是12400

int *pi=&x;

pi+1的内容是12404

char *pc=&x；

pc+1的内容是12401

（3）关系运算

假设有指针变量 px、py。

px > py 表示 px 指向的存储地址是否大于 py 指向的地址
px == py 表示 px 和 py 是否指向同一个存储单元
px == 0 和 px != NULL 表示 px 是否为空指针
//定义一个数组，数组中相邻元素地址间隔一个单元
int num[2] = {1, 3};

（4）地址的赋值

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

//两个指针的指向相同，但是表示的含义不同。

int *pz = num;//数组名表示首元素地址

int *Z=#//整个数组的地址，打印出来还是第一个元素，

区别：Z+1会跳过整个数组，pz+1只跳过第一个元素

三、指针与数组

之前我们可以通过下标访问数组元素，学习了指针之后，我们可以通过指针访问数组的元素。在数组中，数组名即为该数组的首地址，结合上面指针和整数的加减，我们就可以实现指针访问数组元素。

3.1、用指针指向数组（指针数组-->指向数组的指针，本质上是指针）

int nums[10], *p;//有两种方式让指针变量 p 指向数组 nums

//数组名即为数组的首地址
p = nums;
//数组第一个元素的地址也是数组的首地址
p = &nums[0];
上面两句是等价的

3.2、用指针操作数组：

*p = 1，此操作为赋值操作，即将指针指向的存储空间赋值为 1。此时 p 指向数组 nums 的第一个元素，则此操作将 nums 第一个元素赋值为 1，即 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 的意义对于数组操作来说没有意义。会越界访问。很危险

3.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.4、字符指针与字符数组

在 C 语言中本身没有提供字符串数据类型，但是可以通过字符数组和字符指针的方式存储字符串。

（1）字符数组方式

这个在前面应该学习过，这里就不赘述了。

char word[] = "zack";
printf("%s", word);

（2）字符指针方式

指针方式操作字符串和数组操作字符串类似，可以把定义的指针看做是字符数组的数组名。在内存中存储大致如下，这里为了方便换了个字符串：

//除了定义一个字符数组外，还可以直接定义一个字符指针存储字符串
char *sentence = "Do not go gentle into that good night!";

//输出字符串
printf("%s", sentence);//数组名表示首元素地址，然后又%s打印字符串

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

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

注：字符指针方式区别于字符数组方式，字符数组不能通过数组名自增操作，但是字符指针是指针，可以自增操作。自增自减会导致指针的变动。

可以看出：指针与数组有很多相似的地方。

int *pa等价于int arr[ ];    *与[ ]的关系

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        *   arr       [        4         ];
下面举一个简单的例子熟悉指针数组：

int main（）

{

        //定义一个int类型的数组
        int nums[5] = {2, 3, 4, 5, 2}, i;

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

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

        //循环给指针数组赋值
          for(i = 0; i < 5; i++){
                p[i] = &nums[i];
            }
        //数组存放的内容为普通变量，则数组名为变量的指针；数组存放的内容为指针，则数组名为指针的指针。
        pp = p;//p是存放一级指针的数组，数组名表示首元素的地址，把一级指针放到pp，二级指针中

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

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。（可以得出第一个【】是第一个维度，二维个【】是第二个维度）

我们知道数组名即为数组首地址，上面的二维数组有两个维度。

nums数组名代表的是nums[0][n]这一行所有元素的地址，nums+1会跳过整一行。到nums[1][n]这一行。（可以怎么理解：二维数组是多个一维数组的结合，二维数组名，代表第一个元素，第一个元素就是第一个一维数组，这一行）

&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;
}

除了上面的操作，更实用的是返回一个指向数组的指针，这样就实现了返回值为数组。

也有一种形式是创建一个结构体，然后在函数内改变，返回结构体，就可以满足返回多个变量的要求！

4.3、指向函数的指针

C 语言中，函数不能嵌套定义，也不能将函数作为参数传递。但是函数有个特性，即函数名为该函数的入口地址。我们可以定义一个指针指向该地址，将指针作为参数传递。

函数指针定义如下：

数据类型 (*函数指针名)();
函数指针在进行“*”操作时，可以理解为执行该函数。函数指针不同与数据指针，不能进行+整数操作。

下面举个例子，来使用函数指针：

#include<stdio.h>
int add(int a, int b)//加法
{
	return a + b;
}
int main()
{
	int (*p)(int, int);//创建一个函数指针
	int a;
	int b;
	scanf("%d%d", &a, &b);
	p = add;//函数名就是函数的地址，所以可以直接赋值到p
	int n=p(a,b);//保存p函数指针的返回值
	printf("%d", n);
	return 0;
}

关于指针的内容，知识点有很多看起来不咋地，但是到之后用了才知道有多妙，要自己敲代码才能体会的到。

最后最后：如果有哪些地方写的不对，请各位大佬指点一下！