初阶C语言：指针

在初识C语言中我们了解过指针，指针是地址，地址就是指针，我们口头说的指针指的就是指针变量，那么在初阶C语言里面，会对指针的认识再上一个台阶，话不多说，正文开始：

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个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

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

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

2.指针和指针类型

一个变量，有许多种类型：整形、字符型、浮点型...那指针有没有类型呢？

指针也是有类型的，不同类型的地址可以存放在不同的指针中

例如：

int a = 0;
p = &a;

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

定义方式： 指针类型 + *

char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;

其实：

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

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

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

那指针类型的意义是什么？

2.1指针+-整数

#include <stdio.h>
//演示实例
int main()
{
    int n = 10;
    char* pc = (char*)&n;
    int* pi = &n;
    printf("%p\n", &n);
    printf("%p\n", pc);
    printf("%p\n", pc + 1);
    printf("%p\n", pi);
    printf("%p\n", pi + 1);
    return 0;
}

先打印出来看一下结果，然后进行分析

总结：

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

2.2指针的解引用

#include <stdio.h>
int main()
{
    int n = 0x11223344;
    char* pc = (char*)&n;
    int* pi = &n;
    *pc = 0; //重点在调试的过程中观察内存的变化。
    *pi = 0; //重点在调试的过程中观察内存的变化。
    return 0;
}

通过调试的内存窗口可以观察到*操作符对于指针是怎样变换的

总结：

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

3.野指针

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

注意：野指针很危险，类似于生活中的野狗，不受控制，所以在程序中一定要避免野指针的出现

3.1野指针的成因

1.指针未初始化

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

2. 指针越界访问

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

3.指针指向的空间释放

这里先不解释，涉及到动态内存开辟，到时候再解释

3.2如何规避野指针

1. 指针初始化

在创建一个指针时，及时对其初始化

2. 小心指针越界

在使用指针访问一块空间时要预防越界

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

如果不知道指针该指向何处时可以暂时置于NULL

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

#include <stdio.h>
int* test()
{
    int a = 10;
    return &a;   //要避免这样的代码
                 //局部变量出作用域就自动销毁
}
int main()
{
    int*p = test();
    *p = 100;
    return 0;
}

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

#include <stdio.h>
int main()
{
    int* p = NULL;
    int a = 10;
    p = &a;
    //检查指针的有效性
    if (p != NULL)
    {
        *p = 20;
    }
    return 0;
}

4.指针运算

• 指针+-整数

• 指针-指针

• 指针的关系运算

4.1指针+-整数

#include <stdio.h>
int main()
{
    float arr[5];
    float* ap;
    //指针+-整数；指针的关系运算
    for (ap = &arr[0]; ap < &arr[5];)
    {
        *ap++ = 0;
    }
    return 0;
}

4.2指针-指针

关于求字符串的长度我们经常使用strlen函数，我们也可以使用指针来实现这个求字符串长度的函数

//代码1
//strlen函数求字符串长度
#include <string.h>
#include <stdio.h>
int main()
{
    char str[] = { "abcdef" };
    int len = strlen(str);
    printf("len = %d\n", len);
    return 0;
}

//代码2
//实现strlen函数
#include <stdio.h>
int my_strlen(char* str)
{
    char* p = str;
    while (*p != "\0")
    {
        p++;
    }
    return p - str;   //指针-指针
}
int main()
{
    char str[] = { "abcdef" };
    int len = my_strlen(str);
    printf("len = %d\n", len);
    return 0;
}

因此指针-指针得到的是指针和指针之间的元素个数

4.3指针的关系运算

#include <stdio.h>
int main()
{
    float arr[5];
    float* ap;
    //指针+-整数；指针的关系运算
    for (ap = &arr[0]; ap < &arr[5];)
    {
        *--ap = 0;
    }
    return 0;
}

代码优化

#include <stdio.h>
int main()
{
    float arr[5];
    float* ap;
    //指针+-整数；指针的关系运算
    for (ap = &arr[0]; ap < &arr[5]; ap--)
    {
        *ap = 0;
    }
    return 0;
}

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。

标准规定

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

5.指针和数组

指针就是指针，不是数组，指针的大小是4/8个字节，指针是存档地址的，地址的存放需要多大空间，指针变量的大小就是多大
数组就是数组，不是指针，数组的大小取决于数组元素个数和每个元素的类型

先来看一段代码：

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

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

结论：数组名表示的是数组首元素的地址。（2种情况除外）

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

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

1. 指针可以指向数组的元素

2. 指针可以运算，因此可以使用指针来访问数组

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    int* pa = arr;
    int i = 0;
    //初始化
    for (i = 0; i < 10; i++)
    {
        *pa = i + 1;
        pa++;
    }
    pa = arr;//重新给pa赋值
    //打印
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(pa + i));
    }
    return 0;
}

6.二级指针

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

#include <stdio.h>
int main()
{
    int a = 10;//a是要在内存中申请4个字节的空间的
    //一级指针
    int* pa = &a;//0x0012ff40, pa是指针变量，用来存放地址，也得向内存申请，申请4/8
    //二级指针
    int** ppa = &pa;//0x0012ff48
    printf("%d\n", **ppa);
    return 0;
}

a的地址存放在pa中，pa就是一级指针，而pa的地址又存放在ppa中，ppa就是二级指针，当然，如果需要一个pppa来存放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;

7.指针数组

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

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

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

int arr1[5];
char arr2[5];

那指针数组是怎么样的呢？

int* arr3[5];//是什么？

arr3是一个数组，有五个元素，每个元素是一个整形指针。

指针数组该怎么使用呢？

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    //指针数组-存放指针的数组
    int* arr[] = { &a, &b, &c };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        printf("%d ", *(arr[i]));
    }
    return 0;
}

本期分享到此结束，喜欢的老铁们可以点个赞，感谢大家支持！