关于程序员:掌握C语言指针轻松解锁代码高效性与灵活性

✨✨ 欢送大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C 语言学习
贝蒂的主页：Betty‘s blog

咱们都晓得计算机的数据必须存储在内存里，为了正确地拜访这些数据，必须为每个数据都编上号码，就像门牌号、身份证号一样，每个编号是惟一的，依据编号能够精确地找到某个数据。而这些编号咱们就将其称为地址或者指针

数据在内存中的地址称为指针，如果一个变量存储了一份数据的指针（地址），咱们就称它为 指针变量。

那咱们如何应用指针变量呢？

datatype *name;

*示意这是一个指针变量，datatype示意该指针变量所指向的数据的类型

例如：

int* p1;// 指向一个整型的指针
char* p2;// 指向一个字符的指针
float* p3;// 指向一个单精度浮点数的指针
double* p4;// 指向一个双精度浮点数的指针

咱们早在学习 scanf 时候就用过取地址符 &，它是将某个变量的地址取出来，而解援用 * 的意思就是 通过某个地址找到该地址存储的变量。可能解释起来比拟形象，咱们能够通过一个不失当的例子形象阐明一下。

首先咱们能够失去如下几个关系：

    int a = 1;// 第一个客户，&a 为 0x00000001
    int b = 2;// 第二个客户，&b 为 0x00000002
    int c = 3;// 第三个客户，&c 为 0x00000003

而后咱们能够通过指针变量把他们地址存储进去

    int* pa = &a;// 把 a 的地址存进去
    int* pb = &b;// 把 b 的地址存进去
    int* pc = &c;// 把 c 的地址存进去

在酒店中，咱们能够通过门牌号精确找到每个客户。同理，咱们也能够通过每个地址精确找到每个变量。

    printf("a=%db=%dc=%d", *pa, *pb, *pc);// 通过 * 解援用地址找到对应的值

输入后果 a=1 b=2 c=3

并且咱们能够通过指针变量进行赋值。

*pa = 4;
*pb = 5;
*pc = 6;
printf("a=%d b=%d c=%d\n", *pa, *pb, *pc);

输入后果：a=4 b=5 c=6

（1）void* 是一种非凡的指针类型，它能够指向任意类型的数据，就是说能够用任意类型的指针对 void 指针赋值。

void*p1;
int*p2;
p1=p2;// 这是被容许的

然而却 不能把 void* 指针赋值给任意指针类型，也不能间接对其解援用

void*p1;
int *p2;
p2=p1;// 不能这样赋值
*p1// 不能间接对 void* 解援用

（2）NULL 是 C 语⾔中定义的⼀个标识符常量，值是 0，0 也是地址，这个地址是⽆法使⽤的，读写该地址会报错。

int*p=NULL；// 初始化指针

咱们晓得，当初常见的计算机分为 32 位机器 和64 位机器 。32 位机器假如有 32 根地址总线，每根地址线进去的电信号转换成数字信号后是 1 或者 0，那咱们把 32 根地址线产⽣的 2 进制序列当做⼀个地址，那么⼀个地址就是 32 个 bit 位，须要4 个字节能力存储。同理，64 位机器须要 8 个字节能力存储。

咱们能够通过以下代码来验证一下。

int main()
{printf("%zd", sizeof(char*));
    printf("%zd", sizeof(short*));
    printf("%zd", sizeof(int*));
    printf("%zd", sizeof(double*));
    return 0;
}

输入后果：

32 位机器：4 4 4 4

64 位机器：8 8 8 8

咱们先察看一下如下代码的地址变动

#include <stdio.h>
int main()
{
    int n = 10;
    char* p1 = (char*)&n;// 将 int* 强转为 char*
    int* p2 = &n;
    printf("%p\n", &n);
    printf("%p\n", p1);
    printf("%p\n", p1 + 1);//p1 向后挪动一位
    printf("%p\n", p2);
    printf("%p\n", p2 + 1);//p2 向后挪动一位
    return 0;
}

输入：

&n=005DF8D4
p1=005DF8D4
p1+1=005DF8D5
p2=005DF8D4
p2+1=005DF8D8

咱们能够看出，char 类型的指针变量 + 1 跳过 1 个字节，int 类型的指针变量 + 1 跳过了 4 个字节。由此咱们得出结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（间隔）。

因为每次代码运行时，零碎都会从新分配内存，所以输入后果每次都不会一样，然而法则是一样的

咱们晓得数组在内存中是 间断存储 的（地址由低到高），所以咱们只须要只有首元素的地址就能找到数组所有元素的地址，而一维数组的数组名恰好就是咱们首元素的地址。

 假如有数组 int arr[10]={1,2,3,4,5,6,7,8,9,10}

arr	1	2	3	4	5	6	7	8	9	10
下标	0	1	2	3	4	5	6	7	8	9

那咱们如何通过指针拜访每个元素呢？

代码参考如下：

#include <stdio.h>
int main()
{int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int* p = &arr[0];//&arr[0]=arr
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);// 计算数组元素个数
    for (i = 0; i < sz; i++)
    {printf("%d", *(p + i));// 因为数组元素间断存储，所以能够通过 +- 整数找到之后元素
    }
    return 0;
}

输入后果：1 2 3 4 5 6 7 8 9 10

指针 - 指针其实是指在同一空间内，两个指针之间的元素个数。

晓得这点之后，咱们可不可以本人实现一个字符串库函数 strlen()呢?

思路如下：

思路：首先定义两个指针 p1，p2，让两个指针指向首元素，而后让一个指针 p2 循环 ++，直到指向‘\0’就进行，最初返回 p2-p1，就能失去字符串的长度

代码如下：

int my_strlen(char* p1)
{
    char* p2 = p1;// 使两个指针都指向首元素
    while (*p2)
    {p2++;}
    return p2 - p1;// 返回两指针间接的元素的个数就是其长度
}
int main()
{char arr[] = "abcdef";
    int len = my_strlen(arr);// 计算 arr 字符串的长度
    printf("%d\n", len);
    return 0;
}

参考贝蒂 string.h 大全

咱们晓得了指针变量实质是寄存的地址，而地址实质就是 十六进制 的整数，所以 指针变量也是能够比拟大小的。

代码示例：

#include <stdio.h>
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int* p = &arr[0];
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    while (p < arr + sz) // 指针的⼤⼩⽐较
    {printf("%d", *p);// 打印数组每个元素
        p++;
    }
    return 0;
}

咱们晓得变量是能够扭转的，然而在有些场景下，咱们不心愿变量扭转，那咱们该怎么办呢？这就是咱们接下来要讲的 const 的作用啦。

简略来说，通过 const 润饰的变量，能够当做一个常量，而常量是不能扭转的。

    int a = 1;// a 可批改的
    const int b = 2;
    b=3;// b 不可批改的

然而能够通过指针间接批改.

代码如下:

int main()
{
    const int b = 2;
    int* p = &b;
    *p = 3;// 通过指针间接批改
    return 0;
}

咱们晓得 const 的作用后，就能够看看上面几段代码。

    int a = 10;
    const int* p = &a;
    *p = 20;// 是否能够
    p = p + 1;// 是否能够

通过测试咱们发现，* p 无奈扭转成 20，然而 p 能够扭转成 p +1.

那如果把 const 调换一下地位，又会呈现什么状况呢~

    int a = 10;
    int* const p = &a;
    *p = 20;// 是否能够
    p = p + 1;// 是否能够

再次测试之后咱们发现，* p 能够被赋值为 20，然而 p 不能赋值为 p + 1 了

通过上述测试，咱们大抵能够总结出两个论断。

• const 如果放在的右边，润饰的是指针指向的内容，保障指针指向的内容不能通过指针来扭转。然而指针变量本⾝的内容可变。
• const 如果放在 * 的左边，润饰的是指针变量本⾝，保障了指针变量的内容不能批改，然而指针指向的内容，能够通过指针扭转。

assert 是一个宏，它的头文件为 <assert.h>, ⽤于在运⾏时确保程序合乎指定条件，如果不合乎，就报错终⽌运⾏。这个宏经常被称为“断⾔”。

举一个简略的例子：

assert(a>0);

如果 a 确实大于 0，assert 判断为真，就会通过。
如果 a 不大于 0，assert 判断为假，就会报错。

所以 assert 经常用于查看空指针问题，以避免程序因为空指针的问题而出错。

int *p=NULL;
assert(p);// 空指针是 0,0 为假，就会报错

咱们后面学习函数时候，遇到过这样一段代码。

#include<stdio.h>
void swap(int x, int y)// 返回类型为 void 示意不返回值
{
    int temp = 0;// 定义一个长期变量
    temp = x;// 把 x 的值赋给 temp
    x = y;// 把 y 的值赋给 x
    y = temp;// 把 temp 的值赋给 y，实现替换操作
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("替换前：a=%d，b=%d\n", a, b);
    swap(a, b);// 替换函数
    printf("替换后：a=%d，b=%d\n", a, b);
    return 0;
}

输出：3 5

输入：替换后 a =3，b=5

为什么两个值并没有替换呢，这是因为 形参只是实参的一份长期拷贝，对形参扭转，基本不会扭转实参。如果遗记的同学能够再去复习一下贝蒂的函数小课堂

那咱们想在函数中扭转实参的值，那又该如何扭转呢？

其实很简略，咱们学了指针，晓得能够通过地址间接拜访该变量的值，所以咱们只须要把地址传给函数，在函数中通过地址拜访实参，并进行替换。

代码如下：

#include<stdio.h>
void swap(int*x, int*y)// 通过指针变量承受地址
{
    int temp = 0;// 定义一个长期变量
    temp = *x;// 把 * x 的值赋给 temp
    *x = *y;// 把 * y 的值赋给 *x
    *y = temp;// 把 temp 的值赋给 *y，实现替换操作
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("替换前：a=%d，b=%d\n", a, b);
    swap(&a, &b);// 将地址传给函数
    printf("替换后：a=%d，b=%d\n", a, b);
    return 0;
}

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

（1）指针未初始化

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

因为 p 是随机值，所以对 p 解援用，零碎无奈通过 p 的地址找到对应的空间，所以出错造成野指针

（2）数组越界拜访

#include <stdio.h>
int main()
{int arr[10] = {0};
    int i = 0;
    for (i = 0; i < 11; i++)
    {
        // 数组下标是 0 到 9
        printf("%d", *(arr + i));
    }
    return 0;
}

个别呈现这种较大的随机值，个别都是数组越界拜访

（3）指针指向空间开释

#include <stdio.h>
int* test()
{
    int n = 10;
    return &n;// 返回 n 的地址
}
int main()
{int* p = test();// 用 p 承受 n 的地址
    printf("%d\n", *p);// 打印出 n 的值
    return 0;
}

这段代码乍一看，如同并没有什么问题，然而大家在学习函数的时候晓得，在函数中定义的变量是长期变量，一旦 出了作用域就会销毁。

一旦销毁，零碎就无法访问该空间，而通过指针咱们还能够拜访该空间，这就造成了抵触，所以出错，造成野指针。

(1) 初始化

NULL 是 C 语⾔中定义的⼀个标识符常量，值是 0，0 也是地址，这个地址是⽆法使⽤的，读写该地址会报错。如下是 NULL 在编译器中的定义：

ifdef __cplusplus

define NULL 0

else

define NULL ((void *)0)

endif

#include <stdio.h>
int main()
{
    int* p=NULL；// 用空指针初始化，让其有指向地位
    //*p = 20;NULL 地址不能读写
    return 0;
}

(2) 小心越界拜访

咱们在应用数组时候，肯定要对数组的元素个数有一个清晰的把控，不然就很容易呈现越界拜访的状况。

(3) 不能返回长期变量的地址

长期变量出了作用域就会销毁，零碎会回收该空间，所以咱们要尽量避免指针指向曾经销毁的空间，尤其在函数中，不能返回长期变量的地址。

关于程序员:掌握C语言指针轻松解锁代码高效性与灵活性

1. 指针与地址

1.1 概念

1.2 指针变量

1.3 & 和 *

1.4 void* 指针和 NULL

1.5 指针变量的大小

2. 指针的根本运算

2.1 指针 +- 整数

2.2 指针 - 指针

2.3 指针的关系运算

3. const 润饰

3.1 const 润饰变量

3.2 const 润饰指针

4. assert 断言

5. 传值调用与传址调用

5.1 传值调用

5.2 传址调用

6. 野指针

6.1 野指针成因

（1）指针未初始化

（2）数组越界拜访

（3）指针指向空间开释

6.2 解决办法

(1) 初始化

ifdef __cplusplus

define NULL 0

else

define NULL ((void *)0)

endif

(2) 小心越界拜访

(3) 不能返回长期变量的地址

Just My Socks（注册教程内含优惠码）

关于程序员:掌握C语言指针轻松解锁代码高效性与灵活性

1. 指针与地址

1.1 概念

1.2 指针变量

1.3 & 和 *

1.4 void* 指针和 NULL

1.5 指针变量的大小

2. 指针的根本运算

2.1 指针 +- 整数

2.2 指针 - 指针

2.3 指针的关系运算

3. const 润饰

3.1 const 润饰变量

3.2 const 润饰指针

4. assert 断言

5. 传值调用与传址调用

5.1 传值调用

5.2 传址调用

6. 野指针

6.1 野指针成因

（1）指针未初始化

（2）数组越界拜访

（3）指针指向空间开释

6.2 解决办法

(1) 初始化

ifdef __cplusplus

define NULL 0

else

define NULL ((void *)0)

endif

(2) 小心越界拜访

(3) 不能返回长期变量的地址

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）