如何建立自己的网站去推广_企业网站的主要功能_搜狗网站seo_产品线上营销方案

💻作 者 简 介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 C 语 言
💡个 人 主 页：@笑口常开xpr 的 个 人 主 页
📚系 列 专 栏：C 启新程
✨代 码 趣 语：程 序 有 问 题 时 不 要 担 心。如 果 所 有 东 西 都 没 问 题，你 就 失 业 了。
💪代 码 千 行，始 于 坚 持，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee

         在 编 程 的 世 界 里，每 一 行 代 码 都 可 能 隐 藏 着 无 限 的 可 能 性 。你 是 否 想 过，一 个 小 小 的 程 序 究 竟 能 改 变 什 么？它 可 以 是 解 决 复 杂 问 题 的 工 具 ，也 可 以 是 实 现 梦 想 的 桥 梁。今 天，就 让 我 们 一 起 走 进 C 语 言 指 针 的 世 界，探 索 它 的 无 限 潜 力。

内 存

定 义

         内 存 全 称 为 随 机 存 取 存 储 器，简 称 为 RAM，是 计 算 机 中 用 于 暂 时 存 储 数 据 和 程 序 的 组 件。

主 要 作 用

         在 计 算 机 运 行 时，为 CPU 提 供 临 时 的 数 据 存 储 和 访 问 空 间，用 于 存 储 正 在 运 行 的 程 序、数 据 以 及 CPU 处 理 后 的 中 间 结 果 等，以 便 CPU 能 够 快 速 地 读 取 和 写 入 数 据，从 而 保 证 计 算 机 系 统 的 高 效 运 行。

工 作 原 理

         内 存 由 许 多 存 储 单 元 组 成，每 个 存 储 单 元 都 有 一 个 唯 一 的 地 址，就 像 酒 店 的 房 间 号 一 样。CPU 通 过 地 址 来 访 问 内 存 中 的 数 据，当 CPU 需 要 读 取 数 据 时，它 会 向 内 存 发 送 一 个 地 址 信 号，内 存 根 据 这 个 信 号 找 到 对 应 的 存 储 单 元，并 将 其 中 的 数 据 传 输 给 CPU；当 CPU 需 要 写 入 数 据 时，它 会 将 数 据 和 目 标 地 址 发 送 给 内 存，内 存 则 将 数 据 存 储 到 指 定 的 地 址 单 元 中。

内 存 和 程 序 之 间 的 关 系

1、程 序 的 加 载 与 运 行

         当 计 算 机 启 动 并 运 行 一 个 程 序 时，首 先 会 将 程 序 从 硬 盘 等 外 存 储 设 备 加 载 到 内 存 中。这 是 因 为 内 存 的 读 写 速 度 远 远 快 于 外 存，能 让 CPU 快 速 地 访 问 程 序 指 令 和 数 据，以 保 证 程 序 的 高 效 运 行。

数 据 存 储 与 处 理

程 序 在 运 行 过 程 中，会 产 生 各 种 临 时 数 据，如 变 量、中 间 计 算 结 果 等，这 些 数 据 都 存 储 在 内 存 中。内 存 为 程 序 提 供 了 一 个 临 时 的 数 据 存 储 区 域，方 便 程 序 随 时 对 数 据 进 行 读 写 操 作。

内 存 管 理 与 程 序 运 行 效 率

         操 作 系 统 通 过 内 存 管 理 机 制 来 为 程 序 分 配 和 管 理 内 存 空 间。它 负 责 将 内 存 划 分 为 不 同 的 区 域，分 配 给 各 个 正 在 运 行 的 程 序，确 保 每 个 程 序 都 能 获 得 足 够 的 内 存 来 运 行，同 时 避 免 程 序 之 间 的 内 存 冲 突。

内 存 限 制 与 程 序 性 能

         内 存 容 量 是 有 限 的，如 果 程 序 所 需 的 内 存 空 间 超 过 了 系 统 可 用 的 内 存 容 量，就 会 出 现 内 存 不 足 的 情 况。这 时，操 作 系 统 可 能 会 采 用 虚 拟 内 存 技 术，将 一 部 分 硬 盘 空 间 模 拟 成 内 存 来 使 用，但 这 会 导 致 程 序 的 运 行 速 度 明 显 下 降，因 为 硬 盘 的 读 写 速 度 远 低 于 内 存。

指 针

定 义

         指 针 通 常 指 的 是 指 针 变 量，是 用 来 存 放 内 存 地 址 的 变 量，指 针 就 是 地 址，口 语 中 说 的 指 针 通 常 指 的 是 指 针 变 量。在 C 语 言 中，每 个 变 量 在 内 存 中 都 有 一 个 特 定 的 存 储 位 置，而 指 针 变 量 就 是 用 来 记 录 这 些 位 置 的。

大 小

         对 于 32 位 的 环 境，指 针 的 大 小 是 4 个 字 节，对 于 64 位 的 环 境，指 针 的 大 小 是 8 个 字 节，与 指 针 类 型 无 关。

取 地 址 操 作 符

         在 C 语 言 里，& 操 作 符 具 备 两 种 不 同 的 用 途，主 要 有 取 地 址 操 作 符 和 按 位 与 操 作 符 这 两 种 用 途。鉴 于 在 操 作 符 2 中 已 经 对 按 位 与 操 作 符 的 用 法 做 了 详 细 讲 解，下 面 我 将 着 重 介 绍 取 地 址 操 作 符。

基 本 概 念

         在 C 语 言 中，每 一 个 变 量 都 会 在 内 存 里 占 据 一 定 的 存 储 空 间，而 每 个 存 储 空 间 都 有 对 应 的 地 址。取 地 址 操 作 符 & 的 作 用 就 是 获 取 变 量 在 内 存 中 的 起 始 地 址，即 第 一 个 字 节 的 地 址，也 被 称 作 最 小 地 址。

语 法 格 式

取 地 址 运 算 符 是 单 目 操 作 符，它 的 语 法 格 式 为：

&variable;

这 里 的 variable 指 的 是 要 获 取 地 址 的 变 量 名

解 引 用 操 作 符

定 义

         解 引 用 操 作 符 * 用 于 访 问 指 针 所 指 向 的 内 存 地 址 中 存 储 的 值。指 针 本 质 上 是 一 个 变 量，它 存 储 的 是 另 一 个 变 量 的 内 存 地 址，而 解 引 用 操 作 符 就 是 用 来 获 取 这 个 被 指 向 变 量 的 值，然 后 对 其 进 行 修 改。

语 法 格 式

*pointer;

         其 中 pointer 是 一 个 指 针 变 量，* 操 作 符 会 返 回 该 指 针 所 指 向 内 存 位 置 的 值。

指 针 类 型

定 义

指 针 变 量 指 向 的 数 据 类 型，指 针 类 型 由 所 指 向 的 数 据 类 型 决 定。

基 本 格 式

数据类型* 指针变量名;

         数 据 类 型 表 示 指 针 所 指 向 变 量 的 数 据 类 型，* 表 明 这 是 一 个 指 针 变 量。

下 面 展 示代 码 示 例。

#include <stdio.h>
int main()
{int num = 10;//定义一个整型变量num,并初始化为10int* pa = &num;//定义一个整型指针pa//使用取地址运算符&获取num的内存地址,并将其赋值给pa//此时pa存储的就是num在内存中的地址//解引用操作符*用于访问指针pa所指向的内存地址中的值//因为pa指向num,所以*pa就是num的值printf("num 的值是: %d\n", *pa);//这里将*pa的值作为参数传递给 printf 函数进行输出return 0;
}

代 码 解 释

变 量 与 内 存
         在 计 算 机 内 存 中，每 个 变 量 都 有 其 对 应 的 存 储 位 置，这 个 位 置 由 一 个 唯 一 的 地 址 标 识。当 我 们 定 义 一 个 变 量，如 int num = 10;系 统 会 为 num 分 配 一 块 内 存 空 间，用 于 存 储 整 数 值 10。

指 针 的 本 质
         指 针 也 是 一 种 变 量，但 它 存 储 的 不 是 普 通 的 数 据，而 是 另 一 个 变 量 的 内 存 地 址。在 代 码 int* pa = # 中，pa 是 一 个 整 型 指 针，& 是 取 地 址 运 算 符，&num 表 示 获 取 变 量 num 的 内 存 地 址。所 以，pa 存 储 的 就 是 num 在 内 存 中 的 地 址。

解 引 用 操 作 符 *
         解 引 用 操 作 符 * 用 于 访 问 指 针 所 指 向 的 内 存 地 址 中 存 储 的 值。当 我 们 使 用 *pa 时，实 际 上 是 通 过 pa 中 存 储 的 地 址，找 到 对 应 的 内 存 空 间，并 取 出 其 中 存 储 的 值。因 为 pa 存 储 的 是 num 的 地 址，所 以 *pa 就 是 num 的 值。

类 比 理 解

         可 以 把 内 存 想 象 成 一 个 巨 大 的 公 寓 楼，每 个 房 间 都 有 一 个 唯 一 的 房 间 号（内 存 地 址）。变 量 num 就 像 是 住 在 某 个 房 间 里 的 人，而 指 针 pa 则 是 记 录 了 这 个 人 所 在 房 间 号 的 纸 条。当 我 们 需 要 找 到 这 个 人（ 获 取 num 的 值 ）时，就 可 以 通 过 纸 条 上 的 房 间 号（ pa 存 储 的 地 址），去 到 对 应 的 房 间（ 内 存 位 置 ），把 里 面 的 人（ num 的 值）带 出 来，这 个 过 程 就 是 解 引 用 操 作（*pa）。

总 结

pa 里 的 是 num 的 地 址，*pa 是 num 的 值。

意 义

         指 针 类 型 不 仅 决 定 了 指 针 所 指 向 的 数 据 类 型，还 影 响 指 针 在 内 存 中 的 移 动 步 长。例 如，一 个 整 型 指 针 每 次 移 动 会 跳 过 一 个 整 型 数 据 的 大 小（ 通 常 是 4 字 节），而 字 符 型 指 针 每 次 移 动 只 跳 过 一 个 字 符 的 大 小 （ 通 常 是 1 字 节）。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int a = 10;int* pa = &a;char* pc = (char*)&a;//因为a是整型,在大多数系统中整型占用4个字节的内存空间//而pc是字符型指针,字符型指针每次移动一个字节,//为了能让pc指向a的内存地址,需要将a的地址强制转换为字符型指针printf("%p\n", pa);printf("%p\n", pa + 1);//跳过4个字节printf("%p\n", pc);printf("%p\n", pc + 1);//跳过1个字节return 0;
}

直 接 赋 值

#include<stdio.h>
int main()
{int a = 10;printf("修改前a的地址是:%p\n", &a);//使用%p输出a的地址printf("修改前a的值是:%d\n", a);a = 20;printf("修改后a的值是:%d\n", a);printf("修改后a的地址是:%p\n", &a);return 0;
}

间 接 赋 值

#include<stdio.h>
int main()
{int a = 10;int* pa = &a;//&a取出a的第一个字节的地址(较小的地址)//pa --- 指针变量 --- 用来存放地址的变量printf("a的地址是:%p\n", &a);//使用%p输出a的地址printf("a的地址是:%p\n", pa);printf("修改前a的值是:%d\n", a);*pa = 20;printf("修改后a的值是:%d\n", a);printf("修改后a的地址是:%p\n", pa);return 0;
}

区 别

修 改 值 的 方 式
直 接 赋 值：直 接 对 变 量 a 赋 值，将 20 存 入 其 对 应 内 存 位 置，简 单 直 接，适 用 于 简 单 修 改。
使 用 指 针：先 将 变 量 a 的 地 址 赋 给 指 针 pa，再 通 过 解 引 用 操 作 间 接 访 问 并 修 改 a 的 值。

安 全 性
直 接 赋 值：直 接 赋 值 通 常 比 较 安 全，因 为 操 作 的 是 具 体 的 变 量，不 容 易 出 现 指 针 相 关 的 错 误。
使 用 指 针：使 用 指 针 时 需 要 格 外 小 心，因 为 指 针 可 能 指 向 无 效 的 内 存 地 址，从 而 引 发 未 定 义 行 为。

灵 活 性
直 接 赋 值：直 接 赋 值 的 方 式 缺 乏 灵 活 性，在 函 数 内 部 修 改 外 部 变 量 的 值 时 存 在 局 限。例 如，若 要 在 一 个 函 数 里 修 改 另 一 个 函 数 中 的 变 量，直 接 赋 值 就 无 法 实 现。
使 用 指 针：指 针 可 以 作 为 函 数 参 数 传 递，这 样 就 能 在 函 数 内 部 修 改 调 用 函 数 中 的 变 量。

总结

         使 用 指 针 去 修 改 某 个 变 量 的 值 时，变 量 的 值 在 修 改 前 后 会 发 生 改 变，然 而 该 变 量 在 内 存 中 的 地 址 却 保 持 不 变。这 是 因 为 指 针 只 是 通 过 存 储 变 量 的 地 址 来 间 接 访 问 和 修 改 该 变 量 的 值，而 变 量 在 内 存 中 的 存 储 位 置（ 即 地 址 ）一 旦 分 配 好，在 其 生 命 周 期 内 通 常 是 不 会 改 变 的。

指 针 和 数 组 的 关 系

         数 组 的 数 组 名 是 数 组 首 元 素 的 地 址，地 址 是 可 以 放 在 指 针 变 量 中 的，可 以 通 过 数 组 访 问 指 针。

下 面 展 示代 码 示 例。

第 一 种 写 法

#include<stdio.h>
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 + 1;p++;}p = arr;//输出for (i = 0;i < sz;i++){printf("%d ", *p);p++;}return 0;
}

第 二 种 写 法

#include<stdio.h>
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 + 1;//先使用，再++}p = arr;//输出for (i = 0;i < sz;i++){printf("%d ", *p++);//先使用，再++}return 0;
}

重 要

         [ ] 是 个 操 作 符，arr 和 i 是 [ ] 的 操 作 数，满 足 交 换 律。所 以 有 下 面 的 等 式 成 立。

arr[i] = *(arr + i) = i[arr] = *(i + arr)

野 指 针

定 义

         野 指 针 指 的 是 指 向 不 可 用 内 存 区 域 的 指 针。当 使 用 野 指 针 时，程 序 可 能 会 出 现 未 定 义 行 为，因 为 这 些 指 针 指 向 的 内 存 可 能 是 未 分 配 的、已 释 放 的 或 者 根 本 不 存 在 的。

产 生 的 原 因

指 针 未 初 始 化

       定 义 指 针 变 量 时，如 果 没 有 对 其 进 行 初 始 化，指 针 的 值 是 不 确 定 的，它 可 能 指 向 任 意 内 存 地 址。

下 面 展 示代 码 示 例。

#include <stdio.h>
int main()
{int* ptr;//未初始化的指针*ptr = 10;//错误:使用野指针return 0;
}

         在 上 述 代 码 中，ptr 是 一 个 未 初 始 化 的 指 针，它 的 值 是 随 机 的，直 接 使 用 *ptr 会 导 致 未 定 义 行 为。

指 针 越 界 访 问

         当 指 针 指 向 数 组 时，如 果 指 针 超 出 了 数 组 的 有 效 范 围，就 会 变 成 野 指 针。

下 面 展 示代 码 示 例。

#include<stdio.h>
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p = arr;//数组名是数组首元素的地址int sz = sizeof(arr) / sizeof(arr[0]);int i = 0;for (i = 0;i <= sz;i++)//i==sz访问时超出数组下标的范围{printf("%d ", *p);p++;//p向右移动}return 0;
}

现 在 看 下 面 一 段 代 码

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

温 馨 提 示：读 者 们 ，先 自 己 看 代 码，并 写 出 结 果。这 是 提 升 编 程 能 力 的 好 机 会，若 未 达 要 求 ，别 气 馁 ，参 考 下 文 解 析 会 有 新 收 获。

代 码 解 释

         数 组 arr 的 大 小 是 10，类 型 是 int，数 组 arr 的 长 度 为 40 个 字 节，使 用 char* 每 次 指 针 移 动，因 为 char 类 型 占 用 1 个 字 节 的 内 存 空 间，所 以 每 次 对 指 针 p 执 行 p++ 操 作 时，指 针 会 移 动 1 个 字 节 的 内 存 距 离。也 就 是 说，指 针 p 会 依 次 指 向 数 组 arr 所 占 用 内 存 区 域 的 每 个 字 节，通 过 解 引 用 *p 可 以 获 取 并 访 问 该 字 节 所 存 储 的 数 据 值。

现 在 看 下 面 一 段 代 码

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

代 码 解 释

         p 最 开 始 存 储 的 是 数 组 最 后 一 个 元 素 的 地 址。arr 是 数 组 首 元 素 的 地 址，由 于 数 组 下 标 从 0 开 始，对 于 有 10 个 元 素 的 数 组 arr，其 最后 一 个 元 素 的 下 标 是 9，所 以 arr + 9 代 表 的 是 数 组 最 后 一 个 元 素 的 地 址。p - - 则 是 p 向 前 移 动，即 p 向 低 地 址 移 动，以 此 类 推，所 以代 码 的 结 果 是 逆 序 输 出 数 组 元 素。

总 结

         p+n（n是整数）向 后 移 动，也 就 是 向 高 地 址 移 动。p-n（n是整数）向 前 移 动，也 就 是 向 低 地 址 移 动。

指 针 指 向 的 空 间 释 放

下 面 展 示代 码 示 例。

#include<stdio.h>
int* test()
{int a = 10;return &a;
}
int main()
{int *p = test();printf("hehe\n");//函数栈帧被破坏printf("%d\n", *p);return 0;
}

代 码 解 释

局 部 变 量 的 生 命 周 期
         在 test 函 数 里，int a = 10; 定 义 了 一 个 局 部 变 量 a。局 部 变 量 存 储 在 栈 区，当 test 函 数 执 行 结 束 后，其 栈 帧 会 被 销 毁，这 意 味 着 局 部 变 量 a 所 占 用 的 内 存 空 间 不 再 被 该 函 数 使 用，系 统 可 能 会 将 这 块 内 存 重 新 分 配 给 其 他 变 量。

返 回 局 部 变 量 的 地 址
         test 函 数 返 回 了 局 部 变 量 a 的 地 址 &a。在 main 函 数 中，int *p = test(); 把 这 个 地 址 赋 值 给 了 指 针 p。但 由 于 test 函 数 执 行 完 毕 后 其 栈 帧 已 被 销 毁，p 所 指 向 的 内 存 区 域 可 能 已 经 被 其 他 数 据 覆 盖，此 时 p 就 变 成 了 野 指 针。

函 数 栈 帧 被 破 坏
         在 main 函 数 中，调 用 printf(“hehe\n”); 会 引 发 函 数 调 用，这 可 能 会 覆 盖 test 函 数 原 来 的 栈 帧 空 间。所 以，当 执 行 printf(“%d\n”, *p); 时，p 指 向 的 内 存 里 存 储 的 可 能 已 经 不 是 a 的 值，从 而 导 致 未 定 义 行 为， 程 序 可 能 输 出 错 误 的 结 果，甚 至 崩 溃。

规 避 野 指 针

指 针 初 始 化

在 定 义 指 针 时，将 其 初 始 化 为 NULL 或 者 一 个 有 效 的 地 址。

下 面 展 示代 码 示 例。

#include <stdio.h>int main() 
{int* ptr = NULL;//初始化为 NULLint num = 10;ptr = &num;//指向有效的地址printf("%d\n", *ptr);return 0;
}

小 心 指 针 越 界

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

避 免 返 回 局 部 变 量 的 地 址

指 针 使 用 之 前 检 查 有 效 性

总结

         至 此，关 于 C 语 言 指 针 的 探 索 暂 告 一 段 落，但 你 的 编 程 征 程 才 刚 刚 启 航。写 代 码 是 与 机 器 深 度 对 话，过 程 中 虽 会 在 语 法、算 法 困 境 里 挣 扎，但 这 些 磨 砺 加 深 了 对 代 码 的 理 解。愿 你 合 上 电 脑 后，灵 感 不 断，在 C 语 言 的 世 界 里 持 续 深 耕，书 写 属 于 自 己 的 编 程 传 奇，下 一 次 开 启 ，定 有 全 新 的 精 彩 等 待。小 编 期 待 重 逢，盼 下 次 阅 读 见 你 们 更 大 进 步，共 赴 代 码 之 约！