【C语言】指针详解

目录

前言

一. 指针是什么？

二. 指针和指针类型

2.1 指针类型

 2.2 指针+整数

2.3 指针的解引用

三. 野指针

3.1 野指针成因

3.2 如何规避野指针

四. 指针运算

4.1 指针+-整数

4.2 指针-指针

五. 二级指针

六. 指针数组

---

前言

        有些人总觉得指针特别难，特别是刚入门的人听一些大佬说指针好难啊，其实指针就是纸老虎，当我们静下心慢慢学，多敲敲代码，用代码理解，指针也会非常容易学会，这里指针我将分两部分讲，适合新手的内容我将放在这里讲，剩下一部分难点我将在进阶中讲。话不多说，先来一张生活美图，直接开始！

一. 指针是什么？

指针理解的2个要点：

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

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

总结：

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

        我们可以通过&（取地址操作符）取出变量的内存的起始地址，把地址可以存放到一个变量中，这个变量就是指针变量。

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

那一个小的单元到底是多大？

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

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

00000000  00000000  00000000 00000000

00000000  00000000  00000000 00000001

……

111111111  111111111  111111111  111111111

这里就有2的32次方个地址。

每个地址标识一个字节，那我们就可以给（2^32Byte == 2^32 / 1024KB == 2^32 / 1024 /1024 MB == 2^32 / 1024 / 1024 / 1024 GB == 4GB）4G的空间进行编址。

同样的方法，那64位机器，如果给64根地址线，那就能编址16G 的空间。

这里我们就明白：

1. 在32位机器上，地址是32个0或者1组成而精致序列，那地址就得用4个字节来存储，所以一个变量大小就应该是4个字节。

2. 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结：

1.  指针变量是用来存放地址的，地址是唯一标识一个内存单元的。

1.  指针的大小在32位平台上是4个字节，在64位平台是8个字节。

二. 指针和指针类型

2.1 指针类型

指针与其他变量一样也有不同的类型，例如：

        char *pc = NULL;

        int    *pi  = NULL;

        short *ps = NULL;

        long  *pl = NULL;

        float *pf = NULL;

        double *pd = NULL;

这里可以看到，指针的定义方式是： type + *。

其实：char*类型的指针是为了存放char类型变量的地址。

           short * 类型的指针是为了存放short类型变量的地址。

           int*类型的指针是为了存放int 类型变量的地址。

那指针类型有什么意义呢？

1. 指针类型决定了：指针进行解引用操作的时候，访问几个字节。     

例：

        char*的指针解引用访问了1个字节。

        int* 的指针解引用访问了4个字节。

        double*的指针解引用访问8个字节。

2. 指针类型决定了指针的步长（向前或者向后走一步多大的距离）。

例：

        int*指针+1，意思是跳过一个整型，也就是向后走4个字节。

        char*指针+1，意思是跳过一个字符型，也就是向后走1个字节

        double*的指针+1，意思是跳过一个双精度浮点型，也就是向后走8个字节。

 2.2 指针+整数

这里我们引用一个实例：

#include<stdio.h>
int main()
{
    int n = 10;
    char *pc = (char*)&n;    //将a的地址以char*的方式存到指针pc中
    int *pi = &n;            //将a的地址以int*的方式存到指针pi中

    printf("%p\n", &n);        //打印n的地址
    printf("%p\n", pc);        //打印pc的存储的地址
    printf("%p\n", pc + 1);    //打印 pc + 1的存储的地址
    printf("%p\n", pi);        //打印pi的存储的地址
    printf("%p\n", pi + 1);    //打印pi + 1的存储的地址
    return 0;
}      

这里运行结果如下：

         思考上面的实例。我们会发现pc + 1, 跳过1个字节。pi + 1, 跳过4个字节。这是因为它们的不同类型导致的。

总结：

        指针的类型决定了指针向前或者向后走一步有多大（距离）

int my_strlen(char *s)
{
    char *p = s;        //将首地址存储到指针p中
    while(*p != '\0')
    {
        p++;
    }
    return p-s;        //返回 “\0”的地址减去首地址的数
}

2.3 指针的解引用

这里同样用实例来解释：

#include<stdio.h>
{
    int n = 0x11223344;    //将一个十六进制的值存储到n中
    char *pc = (char *)&n; //取n的地址存储到指针pc中
    int *pi = &n;          //取n的地址存储到指针pi中
    *pc = 0;       //这里内存的变化下面讲解     
    *pi = 0;       //这里内存的变化下面讲解  
    return 0;
}

这里n的值在内存中为：44 33 22 11

 

执行*pc = 0 后 44 变为 00。是因为 pc 是char*型的，向后访问1个字节。

 

 执行*pi = 0 后 n 全变为0；是因为 pi 是 int*型的，向后访问4个字节。

总结：

        指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

  比如： char*的指针解引用就只能访问一个字节，而int*的指针的解引用就能访问四个字节。

三. 野指针

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

3.1 野指针成因

        1. 指针未初始化。

        2. 指针越界访问。

        3. 指针指向的空间释放。

例子如下：

#include<stdio.h>
void *test()
{
    int a = 10;
    return &a;
}
int main()
{
    int *p; //局部变量指针未初始化，默认为随机值。
    int arr[10] = { 0 };
    int i = 0;
    for(i = 0; i <= 11; i++)
    {
        *(p++) = i;    //当指针指向的范围超出数组arr的范围时，p就是野指针。
    }
    //指针指向的空间释放实例：
    int *pa = test();
    printf("%d\n", *pa); //&a出test函数空间就释放了
    return 0;
}

3.2 如何规避野指针

1. 指针初始化

2. 小心指针越界

3. 指针指向空间释放，及时置NULL

int *pa = NULL;        //NULL= 0,空指针，没有指向任何地址

// *pa = 20;错误，因为pa已置空

if ( p != NULL)        //用指针之前最好判断一下是否为空

{

        ；

}

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

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

四. 指针运算

4.1 指针+-整数

前面2.1主要讲了指针的类型决定了指针向前或者向后走一步有多大（距离），理解了这句话指针+-整数就掌握的OK了，下面用实例来理解

实例：用指针来初始化数组

（指针+整数）

#include<stdio.h>
int main()
{
    int arr1[5] = { 1, 2, 3, 4, 5};
    int* p;

    for (p = &arr1[0]; p < &arr1[5]; )
    {
        *p = 0; //将指针p指向的数组地址上的变量赋值为0；
        p++;   //指针p是int型，+1：一次向前访问4个字节
    }

    int i = 0;  //这里打印数组
    for (i = 0; i < 5; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

（指针-整数）

#include<stdio.h>
int main()
{
    int arr1[5] = { 1, 2, 3, 4, 5};
    int* p;
    for (p = &arr1[4]; p >= &arr1[0]; )    //这里将arr1[4]的地址存储到指针p中
    {
        *p = 0; //将指针p指向的数组地址上的变量赋值为0；
        p--;   //指针p是int型，-1：一次向前访问4个字节
    }

    int i = 0;  //这里打印数组
    for (i = 0; i < 5; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

注意：上面指针-整数实际在绝大部分编译器是可以顺利完成的，然而我们还是应该避免这样写，因为标准并不保证它可行。

标准规定：

        允许执行数组元素的指针与指向数组与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

 

4.2 指针-指针

指针相减的前提：指针指向的是同一块连续的空间，两指针相减的结果是距离。

这里我们用指针减指针来实现一个strlen函数。

//指针实现strlen
int my_strlen(char *s)
{
    char *p = s;        //将首地址存储到指针p中
    while(*p != '\0')
    {
        p++;
    }
    return p-s;        //返回 “\0”的地址减去首地址的数
}

指针的关系运算

指针和数组

我们看如下一个例子：

#include<stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9};
    printf("%p\n",arr);
    printf("%p\n",&arr[0]);
    return 0;
}

运行结果：

由上实例可知数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。（2种情况除外，具体看我之前讲解数组的文章）

那么可以把数组名当成地址存放到一个指针中。

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int  *p = arr;    //p存放的是数组首元素的地址。

那么是不是也直接通过指针来访问数组，看看下面的实例就知道了

#include<stdio.h>
int main()
{
    int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int *p = arr;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for(i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p  <=====> p + %d = %p\n", i, &arr[i], i, p+i);
    }
    return 0;
}

运行结果：

观察上面的地址，我们可以发现p + i 其实计算的是数组arr下标为i 的地址。

那我们也可以直接通过指针来访问数组。如下：

//用指针打印数组
#include <stdio.h>
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    int *p = arr;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for(i = 0; i < sz;  i++)
    {
        printf("%d\n", *(p + i));    //打印数组的内容
    }
    return 0;
}

五. 二级指针

前面提过指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

答案：二级指针

        如上图，a的地址存放在pa中，pa的地址存放在ppa中。pa是一级指针，而ppa是二级指针。

对于二级指针的运算有：

*ppa 通过对 ppa 中的地址进行解引用，实际找到的是pa 的地址， *ppa其实访问的就是pa。

int b = 20;
*ppa = &b; //等价于pa = &b;

**ppa先通过*ppa找到pa,然后对pa进行解引用操作：*pa,那找到的是a。

**ppa = 30;
//等价于*pa = 30;
//等价于 a = 30;

六. 指针数组

指针数组是一个存放指针的数组。

指针数组就是把相同类型的指针存储到一起的数组，例如：

 

arr是一个数组，有五个元素，每一个元素是一个整型指针。剩下的难点我将放在进阶讲。

好了，到这里就结束了，不过关于指针的了解仅仅在这个程度还不够，更深入的内容我将放在进阶进讲。码字不易，请多支持，我们下期再见！