[ C语言 ] 还不懂指针的一定要进来，带你初始指针，简单使用指针，它没有你想的那么难。

前言

本篇博客主要是初始指针，简单使用指针，在日常的使用解决问题中运用指针。

提示：以下是本篇文章正文内容

一. 指针是什么？

指针:是内存单元的编号，也就是指针。

指针理解的2个要点：

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

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

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

所以我们可以理解为：内存

内存单元 - 编号 - 地址 - 指针

平时口语中的指针是指针变量，是存放内存变量的

内存被划分为一个个小的内存单元 一个基本的内存单元的大小是一个字节

地址： 内存单元的编号 0X00000000

内存单元编号的产生： 32位机器-32跟地址线-物理的电线- 通电-1/0

                00000000 00000000 00000000 00000000 -- 4个字节

                00000000 00000000 00000000 00000001

                00000000 00000000 00000000 00000010

                ....     ...      ...      ...

                11111111  11111111 11111111 11111111

                2*10^32 bite   -- 4GB

64位

**指针变量 **

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个

变量就是指针变量

int main()
{
    int a = 10;// 四个字节

    int* pa = &a;//pa存的是地址 所以pa就是指针变量
    printf("%d\n", sizeof(pa));
    printf("%p", &a);
    return 0;
}

下面这张图可便于大家理解：

举例：

int main()
{
    int a = 0x11223344;
    int* pa = &a;
    *pa = 0;
    //char* pc = &a;
    //*pc = 0;
    //int*   --> 4
    //char*   --> 1
    //double*   --> 8

    return 0;
}

地址的打印：

二. 指针和指针类型

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

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

准确的说：有的。

int main()
{
    int a = 10;
    int* pa = &a;//整形  --4 
     char* pc = &a;//字符 --1
    printf("%p\n", pa);
    printf("%p\n", pa+1);

    printf("%p\n", pc);
    printf("%p\n", pc+1);

    //指针类型决定了指针向前或者向后走一步走的距离 -- 单位是字节
    return 0;
}

指针类型决定了指针向前或者向后走一步走的距离 -- 单位是字节

指针的定义方式是： type + * 。

其实：

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

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

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

**2.1 ****指针的解引用 **

**总结： **

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

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

2.2** 指针+-****整数 **

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

举例：

分析：

int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        //正着初始化
        *(p+i) = i+1;
    }
    //正着打印
    int* m = &arr[0];
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *m);
        m++;
    }
    printf("\n");
    //倒着打印  9 8 7 ...
    int* q = &arr[9];
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *q);
        q--;
    }
    return 0;
}

演示分析：

三. 野指针

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

**3.1 ****野指针成因 **

1. 指针未初始化

int main()
{
    int* p;//局部变量指针未初始化，默认为随机值
    *p = 20;
    return 0;
}

2. 指针越界访问

    int arr[10] = { 0 };
    int* p = arr;
    for (int i = 0; i <= 10; i++)
    {
        *p = i;
        p++;
    }

3. 指针指向的空间释放

//指针指向的空间释放

int* test()
{
    int a = 100;
    return &a;
}
int main()
{
    int* p = test();
    printf("%d", *p);
    return 0;
}

int main()
{
    int a = 10;
    int* pa = &a;// 知道存给谁

    int* p = NULL;//初始化成空指针
    if (p != NULL)
    {

    }

    return 0;
}

分析：

3.2 如何规避野指针

四. 指针运算

**4.1 指针+-**整数

初始化并赋值打印
int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++)
    {
        *(p + i) = i+1;
    }
    //打印
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(p + i));
    }
    return 0;
}

**4.2 指针-****指针 **

int main()
{
    /*int a[10] = { 0 };
    
    printf("%d\n", &a[9] - &a[0]);
    printf("%d\n", &a[0] - &a[9]);*/

    int a = 10;
    char c = 'w';

    return 0;
}

分析：

举例2：求字符串的长度

在之前我们用strlen函数写了可以求字符串的长度

//求字符串长度的函数 strlen
#include <string.h>

int My_strlen(char* s)
{
    int count = 0;
    while(*s != '\0')
    {
        count++;
        s++;
    }
    return count;

}
int main()
{
    char arr[] = "abc";
    int len =My_strlen(arr);

    printf("%d\n", len);
    
    return 0;
}

同样我们也可以使用指针减指针的方法

int My_strlen(char* s)
{

    char* start = s;
    while (*s != '\0')
    {
        s++;
    }
    return  s - start;
}
int main()
{
    char arr[] = "abc";
    int len =My_strlen(arr);

    printf("%d\n", len);
    
    return 0;
}

分析：

**4.3 **指针的关系运算

int main()
{
    float a[5];
    float* p;
    for (p = &a[5]; p >= &a[0];)
    {
        *--p = 0;
    }
    return 0;
}

改进：

    for (p = &a[4]; p >= &a[0]; p--)
    {
        *p = 0;
    }

**标准规定： **

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与

指向第一个元素之前的那个内存位置的指针进行比较。

五. 指针和数组

 指针 -- 地址
 数组 -- 一组相同类型的数据
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //arr首元素地址
    int* p = arr;
    int i = 0;
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        printf("%p == %p \n", p + i,&arr[i]);
    }

    return 0;
}

分析：

可见数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。

那么这样写代码是可行的：

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

int *p = arr;//p存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

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("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
    }
    return 0;
}

所以 p+i 其实计算的是数组 arr 下标为i的地址

六. 二级指针

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

这就是 二级指针 。

int main()
{
    int a = 10;
    int* pa = &a;
    int** ppa = &pa; //ppa就是一个二级指针
    **ppa = 20;
    printf("%d\n",a);

    return 0;
}

七. 指针数组

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

答案：是数组。是存放指针的数组。

数组我们已经知道整形数组，字符数组

int main()
{
    int arr[10];//整形数组
    char ch[5];//字符数组

    //指针数组 --- 存放指针的数组
    int a = 10;
    int b = 20;
    int c = 30;
    int* arr2[5] = {&a,&b,&c};//存放整形指针的数组
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        printf("%d ", *(arr2[i]));
    }
    return 0;
}

总结

本篇文章大致总结了指针在日常学习中的简单使用，如果看完对大家有所帮助的话，希望大家点赞收藏+关注，感谢各位大佬们的支持，若文章出现错误，也请大佬们及时指正。

最后附上完整板书：2021_12_28 指针/指针.png · 李兴宇/C语言 - Gitee.com

全部代码：2021_12_28 指针/2021_12_28 指针/test.c · 李兴宇/C语言 - Gitee.com