1、指针是什么

指针是什么？

指针理解的2个要点：

​ 1、指针是内存中一个最小单元的编号，也就是地址。

​ 2、平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常是指指针变量。

指针变量

​ 我们可以通过&(取地址操作符)取出变量的内存存储地址，把地址可以存放在一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
    int a = 10;    //在内存中开辟一块空间
    int* p = &a;   //这里我们对变量a，取出它的地址，可以收用&操作符
                  //a变量占用4个字节的空间，这里将a的4个字节的第一个字节的地址存放在p变量中，p就是指针变量。
    return 0;
}

总结：

指针变量，用来存放地址的变量。（存放在指针中的值都被当作成地址处理）。

那这里有些问题：

• 一个小的单元到底是多大？（1个字节）
• 如何编制？

如何编制？也就是说内存编号/地址是如何产生的呢？

对于一个32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或0）。

那么32根地址线产生的地址就会是：

00000000000000000000000000000000

00000000000000000000000000000001

...

11111111111111111111111111111111

一共会有2的32次方个地址。

每个地址标识一个字节，那我们就可以给2^32Byte == 2^32/1024 == 2^32/1023/1024 == 2^32/1024/1024/1024 ==4GB，4G的空闲进行编址。同样的方法，那64位机器，如果给64根地址线，也是一样的计算方法。

这里我们就明白：

• 在32位的机器上，地址是32个0或者1组成的二进制序列，那地址就得用4个字节（32bit / 8bit = 4byte）的空间来存储，所以一个指针变量的大小就应该是4个字节。
• 那如果在64位机器上，如果有64个地址线，那一个指针变量大小就是8字节，才能存放一个地址。

总结：

• 指针变量是用来存放地址，地址是唯一标示一块地址空间的。
• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

2、指针和指针类型

这里我们讨论一下：指针的类型。

我们都知道，变量有不同的类型：整型，浮点型等。那指针有没有类型呢？

准确的说：有！

如下代码：

int num = 0;
p = #

要将&num（变量num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？我们给指针变量相应的类型：

char* pa = NULL;
int* pb = NULL;
short* pc = NULL;

下面看段代码来讨论个问题：

#include <stdio.h>
int main()
{
    char* pa = NULL;
    short* pb = NULL;
    int* pc = NULL;
    double* pd = NULL;
    printf("%zu\n", sizeof(pa));   //sizeof()返回的值，最好用%zu来表示。
    printf("%zu\n", sizeof(pb));
    printf("%zu\n", sizeof(pc));
    printf("%zu\n", sizeof(pd));
    return 0;
}

输出：由于我这里是x64环境，所以显示都是8，x86会显示都是4

那么现在来考虑个问题：既然char类型的指针，和int类型的指针，和short类型的指针，和double类型的指针占用内存空间都是一样的，那为什么需要分类型呢？怎么不直接声明个统一的类型呢？

其实每一个指针类型是有意义。

指针类型第一个意义：

结论：指针类型决定了指针在被解引用的时候访问几个字节，如果是int*的指针，解引用访问4个字节，如果是char*的指针，解引用访问1个字节，其它的也是同样道理。

举个例子：我们声明个int类型的a变量，然后取a地址&a，用char去接收，那这样我们在解引用\pa时，只能访问a变量的第一个字节里面的值，因为a是类型的变量，占用4个字节，但是这时只能访问第一个地址里面的值。

#include <stdio.h>
int main()
{
    int a = 0;
    char* pa = &a;
    *pa = 1;
    return 0;
}

指针类型第二个意义：

结论二：指针的类型决定了指针+1或者指针-1操作的时候，跳过几个字节，也就是决定了指针的步长。

举个例子：我们用char*和int*来存储同一个变量的内存地址，值应该是一样的

#include <stdio.h>
int main()
{
    int a = 0;
    int* pa = &a;
    char* pc = &a;
    printf("pa = %p\n", pa);
    printf("pc = %p\n", pc);
    return 0; 
}

输出：

但是现在我输出pa+1和pc+1，这个时候就会出现差异：

#include <stdio.h>
int main()
{
    int a = 0;
    int* pa = &a;
    char* pc = &a;
    printf("pa = %p\n", pa);
    printf("pa = %p\n", pa+1);
    printf("--------------------------------\n");
    printf("pc = %p\n", pc);
    printf("pc = %p\n", pc+1);
    return 0; 
}

输出：

那这个时候，会发现当打印pa+1，pc+1时，由于pa指针是int类型的，所以在pa+1之后整体内存是直接加了4个字节的过程。而由于pc指针是char类型的，所以在pa+1之后整体内存是直接加了1个字节的过程。

这就是指针类型的第二个意义。

这样的效果有什么实际的作用吗？肯定有！

比如：当我们想解引用访问一个变量时，我们可以选择跳过访问时就可以使用int类型的指针，选择一个一个的访问时就可以使用char类型的指针。这个需要看个人需求。

指针类型意义补充：int类型的和folat类型的用的效果一样吗？

先看如下代码：

#include <stdio.h>
int main()
{
    int a = 0;
    int* pa = &a;     //pa解引用访问4个字节，pa+1也是跳过4个字节
    float* pf = &a;   //pf解引用访问4个字节，pf+1也是跳过4个字节
    return 0; 
}

我们知道int类型的占用4个字节，folat也是占用4个字节。

所以pa解引用访问4个字节，pa+1也是跳过4个字节，同样，pf解引用访问4个字节，pf+1也是跳过4个字节。

其实pa和pl的权限是一样的，但是最终的效果却是不一样的。

所以pa和pl也不能混用。

总结

不同类型之间的指针，解引用就两条意义：

• 解引用访问时访问不同的字节
• pi+1或者pi-1跳过不同的字节。

指针类型练习题（一）

输出结果：0 0 3 4 5

分析：首先arr数组中存放了：1 2 3 4 5，它们在内存中是这样存储的：

首先要注意：这里有个大小端字节序：数据在内存中存放的时候，有一个顺序的问题，数据是倒放的。

具体是怎么到访的呢？比如说int i = 1; 首先i是int类型的数据，占4个字节，那么1按常理说十六进制是：0x 00 00 00 01。但这里的数据需要倒放，所以说1在内存中存储的形式就应该是：01 00 00 00。就是完全倒过过来的。所以说arr数组的数据整体在内存中存放的顺序就应该是：

arr数组名也是数组首元素地址，然后把arr强制类型转换为short*，此时就引用到了上面所讲到的指针类型的意义了。shor*类型的指针，一次只能访问两个字节数据，所以当第一次循环时，只是前两个字节的赋值为0了，然后第二次循环时第三个和第四个字节的数据赋值为0，然后第三次循环，是第五六字节赋值为0了，然后是第四次循环也就是最后一次循环，第七八字节的数据赋值为0了。如下图所示：

并且后面的值没有改变，所以输出：0 0 3 4 5。

指针类型练习题（二）

前提：十六进制数字中两个数字占一个字节，比如：0x11223344，11占用一个字节，22占用一个字节，33占用一个字节，44占用一个字节

输出：112233

首先a变量在内存中存放数据的顺序是倒放：

由于char pc = (char)&a; 且char*类型的指针，只能给访问一个字节，所以说*pc = 0，就把上面44全部变为00了。又因为%x是以十六进制输出，所以输出为：112233。

3、野指针

概念：野指针就是指针指向的位置时不可知的（随机的，不正确的，没有明确限制的）

3.1、野指针成因

1、指针未初始化

#include <stdio.h>
int main()
{
    int* p;    //指针未初始化，因为着没有明确的指向
    *p = 10;   //非法访问内存，这里的p就是野指针
    return 0; 
}

2、指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    int* p = arr;   //arr=&a[0]
    int  i = 0;
    for (i = 0; i <= 10; i++)
    {
        *p = i;          //当i=10时，属于越界访问，当指针指向的范围超出数组arr的范围时，p就是野指针
        p++;
    }
    return 0; 
}

3、指针指向的空间释放

这里放在动态内存开辟的时候讲解。

3.2、如何避免野指针

1、指针初始化

2、小心指针越界

3、指针指向空间释放即使置NULL

4、避免返回局部变量的地址

5、指针使用之前检查有效性

int* p1 = NULL;       //指针初始化为空值

4、指针运算

• 指针+/-整数
• 指针 - 指针
• 指针的关系运算

4.1、指针+/-整数

看如下代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int* p = arr;
    for (i = 0; i < sz; i++)
    {
        *p=1;
        p++;
    }
    return 0;
}

扩展：

#include <stdio.h>
int main()
{
    #define N_VALUES 5
    float values[N_VALUES];     //创建个float类型的数组
    float* vp;
    for (vp = &values[0]; vp < &values[N_VALUES];)
    {
        //这个相当于两步操作：1、*vp = 0     2、vp++
        *vp++;        
    }
    return 0;
}

4.2、指针-指针

看如下代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("%d", &arr[9] - &arr[0]);
    return 0;
}

输出：

那如果是&arr[0] - &arr[9]呢？

答案是-9。

结论：|指针 - 指针|（绝对值）得到的是指针和指针之间元素个数。

4.3、指针的关系运算

5、指针和数组

数组：一组相同类型元素的集合。

指针变量：是一个变量，存放的是一个地址。

数组是数组，指针是指针。本质上二者没有联系，但是我们通过指针来操作数组。

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(p + i));
    }
    return 0;
}

输出：

补充：arr[i]就相当于*(arr+i)。这是本质。

6、二级指针

先看段代码：

#include <stdio.h>
int main()
{
    int a = 0;
    int* pa = &a;    //pa是一个指针变量，一级指针变量
    int* * ppa = &pa;   //ppa是一个二级指针变量
    **ppa = 20;
    printf("%d", a);
    return 0;
}

输出：

pa经过一次解引用就可以访问到a，称为一级指针变量。

ppa经过两次解引用才可以访问到a，称为二级指针变量。

二级指针变量是用来存放一级指针变量的地址。

然后**ppa相当于解两次引用，所以可以访问到a。

下面来分解一下：

7、指针数组

指针数组是指针还是数组？

指针数组：存放指针的数组就是指针数组。

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int* parr[10] = { &a,&b,&c };   //paar就是指针数组
    return 0;
}

然后遍历指针数组进行读取a，b，c的值：

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int* parr[10] = { &a,&b,&c };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        //paar[i]是找到指针数组中的每一个元素，也就是&a,&b,&c，然后在*解引用，即可访问到指定的变量
        printf("%d ", *(parr[i]));
    }
    return 0;
}

输出：

7.1、用指针数组模拟二维数组

如下代码：

#include <stdio.h>
int main()
{
    int arr1[4] = { 1,2,3,4 };
    int arr2[4] = { 2,3,4,5 };
    int arr3[4] = { 3,4,5,6 };
    int* parr[3] = { arr1,arr2,arr3 }; 
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 4; j++)
        {
        //parr[i]相当于遍历出：arr[0],arr[1],arr[2]，然后parr[i][j]相当于遍历出：arr[0][1]...
            printf("%d ", parr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

输出：

图解上述：