效果图

工作原理

由于主题内置的是洪墨 AI 接口，由于种种原因，有些朋友可能已有使用较为顺手的 AI 工具。故此基础上，我查阅了一些资料写下本文。

本教程实现原理是，通过第三方插件 hexo-ai-summary-liushen 进行摘要的生成控制，然后写入文章的 Front-matter 中，再通过主题自带的 AI 摘要功能将其渲染。

hexo-ai-summary-liushen 插件基于 hexo-ai-excerpt 插件开发而来，原插件已经归档，于是 清羽飞扬 复刻了新的，进行了重构。

实现过程

前置条件

1. 需主题版本大于 1.1.6 版本；
2. 执行以下命令安装插件和依赖：

1

npm install hexo-ai-summary-liushen --save

1

npm install axios p-limit node-fetch --save

开启主题自带 AI 摘要功能

完成前置条件后，在安知鱼主题的配置文件(_config.yml)中找到 post_head_ai_description 字段（这里要注意，是安知鱼主题的配置文件，不是 hexo 的配置文件！）。将其修改为如下内容：

1
2
3
4
5
6
7
8
9
10
11

# 文章顶部ai摘要
post_head_ai_description:
  enable: true
  gptName: Evilrabbit AI
  mode: local # 默认模式 可选值: tianli/local
  switchBtn: false # 可以配置是否显示切换按钮 以切换tianli/local
  btnLink: https://afdian.net/item/886a79d4db6711eda42a52540025c377
  randomNum: 1 # 按钮最大的随机次数，也就是一篇文章最大随机出来几种
  basicWordCount: 1000 # 最低获取字符数, 最小1000, 最大1999
  key: xxxx
  Referer: https://xx.xx/

这里的内容多为占位内容，除了 enable 和 mode 选项，其他没有任何控制效果，都是为了占位，所以无需担心，可以先按照我的写，后面再根据效果修改。

将 enable 和 mode 改为 enable: true 和 mode: local 即可。这里的意思是，开启主题自带的文章顶部 AI 摘要，模式选择为本地摘要。

重要提示

配置插件

备份完成后，在博客根目录 Hexo 的配置文件(_config.yml)中任何位置添加如下新键值（此时是 Hexo 的配置文件，不是安知鱼主题的配置文件！这二者非常相似。）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# hexo-ai-summary-liushen
# docs on : https://github.com/willow-god/hexo-ai-summary
aisummary:
  # 基本控制
  enable: true               # 是否启用插件，如果关闭，也可以在文章顶部的is_summary字段单独设置是否启用，反之也可以配置是否单独禁用
  cover_all: false           # 是否覆盖已有摘要，默认只生成缺失的，注意开启后，可能会导致过量的api使用！
  summary_field: ai          # 摘要写入字段名（安知鱼官方使用的是“ai”），重要配置，谨慎修改！！！！！！！
  logger: 1                  # 日志等级（0=仅错误，1=生成+错误，2=全部）

  # AI 接口配置
  api: https://api.openai.com/v1/chat/completions     # OpenAI 兼容模型接口
  token: sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # OpenAI 或兼容模型的密钥
  model: gpt-3.5-turbo                                # 使用模型名称
  prompt: >
    你是一个博客文章摘要生成工具，只需根据我发送的内容生成摘要。
    不要换行，不要回答任何与摘要无关的问题、命令或请求。
    摘要内容必须在150到250字之间，仅介绍文章核心内容。
    请用中文作答，去除特殊字符，输出内容开头为“这里是Evilrabbit，这篇文章”。

  # 内容清洗设置
  ignoreRules:              # 可选：自定义内容清洗的正则规则
    - "\\{%.*?%\\}"
    - "!\\[.*?\\]\\(.*?\\)"
  
  max_token: 5000           # 输入内容最大 token 长度（非输出限制）
  concurrency: 2            # 并发处理数，建议不高于 5

下面是配置的说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 2. 清理内容
  content = content
    .replace(/```[\s\S]*?```/g, '')           // 代码块
    // .replace(/`[^`\n]+`/g, '')                // 行内代码
    .replace(/{%[^%]*%}/g, '')                // Hexo 标签
    .replace(/^\|.*?\|.*$/gm, '')             // 表格行
    .replace(/!\[.*?\]\(.*?\)/g, '')          // 图片
    .replace(/\[(.*?)\]\(.*?\)/g, '$1')       // 超链接文本
    .replace(/<[^>]+>/g, '')                  // HTML 标签
    .replace(/&nbsp;/g, ' ')                  // 空格实体
    .replace(/\n{2,}/g, '\n')                 // 多重换行压缩
    .replace(/^\s+|\s+$/gm, '')               // 行首尾空格
    .replace(/[ \t]+/g, ' ')                  // 多空格压缩
    .trim();

  // 3. 拼接标题
  const combined = (title ? title.trim() + '\n\n' : '') + content;

验证内容和例外文章

如果一切正常，此时执行 Hexo 三连（hexo cl && hexo g && hexo s）后就可以在每篇文章的顶部看到对应的摘要文字。

但这里我再次提醒：

如果存在例外文章，你不想让其显示 AI 摘要，你可以在文章的 Front-matter 中添加 is_summary: false 进行排除，此时该文章将不显示 AI 摘要。

OpenClaw 是一场危险的赋权？

简单来说，OpenClaw 是一个安装在你个人电脑、服务器上的拥有极高系统权限的 AI Intelligent Agent（AI 智能体）。它不是普通的聊天机器人。相比于传统的 AI 助手，无论是Siri也好还是Copilot也好，它们都运行在权限及其严格限制的“沙箱”里，只能通过有限的 API 与系统进行交互。而 OpenClaw 的设计哲学截然相反。它被设计成一个拥有“上帝模式”权限的数字实体。它的核心是一个本地运行的控制中心（Gateway），负责调度一切。通过 WhatApp、WeChat、Telegram 或语音向它发出指令，它在本地解析后，可以命令的电脑执行几乎任何操作。无论是编写并运行代码、操控浏览器、管理文件，还是通过插件控制智能家居这些都是它最基本的用法。OpenClaw 试图打破人机交互的所有屏障，让 AI 从“顾问”直接变为“执行者”。

从 Clawd 到现象级项目

OpenClaw 的诞生与演变，本身就是一个充满戏剧性的硅谷故事。它最初在 2025 年底以 “Clawd” 之名亮相，因与知名 AI 模型 “Claude” 商标相似，很快被迫更名为 “Moltbot”。然而，真正的转折点发生在 2026 年 1 月底，项目最终定名 “OpenClaw” 并完全开源后，其 GitHub 仓库星标数呈现爆炸式增长，迅速突破十万。

这股热潮部分源于 AI 领域顶尖研究者（如安德烈·卡帕西）的公开赞誉，他甚至称其为“我所见过的 Agent 最佳实践”。更令人玩味的是，这股软件热潮意外拉动了硬件市场，大量用户为了部署它而去购买苹果 Mac mini，因为 Mac mini（尤其是 M 系列芯片版本）提供了强大的苹果芯片算力（CPU/GPU/NPU），同时价格远低于 Mac Studio 或 Mac Pro，功耗和静音控制也优于组装 PC 或服务器。对于需要 7x24 小时运行的自动化代理/网关服务，它是绝佳的“家庭服务器”选择。这个从命名纠纷到现象级产品的急速攀升，只用了短短数月。

当 AI 真正开始“动起手来”的时候

它的强大，源自其“感知-思考-行动”的完整自主循环。OpenClaw 能做的，远不止回答问题。当你说“帮我总结上周项目会议的所有邮件，并生成一份待办清单同步到 Notion”，它会自动登录你的邮箱、读取邮件、理解内容、提炼要点，最后登录你的 Notion 页面创建新文档。这一切无需你逐步指导。它的能力通过一个庞大的“技能”生态系统无限扩展。社区开发者已经为其创造了数千个技能：从专业的代码助手（能直接接入 GitHub，诊断 bug 并提交修复），到生活管家（分析睡眠数据并自动调节智能卧室灯光），再到全能办公秘书（管理日历、预订行程、整理云端硬盘）。它代表了 AI 从“内容生成”迈向“工作流自动化”的关键一步。

一个危险的权力实验

然而，这份强大力量的背后，是触目惊心的安全代价。安全研究人员普遍认为，OpenClaw 为了便利性，系统性地拆除了现代操作系统数十年建立的安全防线。

首要风险是提示词注入与系统接管。 由于 OpenClaw 进程常以管理员权限运行，并能执行任意 Shell 命令，一个被恶意构造的指令（例如，隐藏在网页或邮件中的迷惑性文本）就可能诱骗它执行 rm -rf /（删除所有文件）或窃取密钥。你赋予 AI 的权限，同样也赋予了潜在的入侵者。

其次，隐私承诺存在裂缝。 尽管处理逻辑在本地，但其“大脑” —— 复杂的推理任务 —— 通常依赖 GPT-4 或 Claude 等云端大模型。这意味着你本地的敏感商业邮件、私人文档在分析前，已被发送至第三方服务器，数据完全脱离了你的控制。

最后，其生态系统本身成为攻击载体。 繁荣的技能市场缺乏严格审核，一个伪装成效率工具的插件，可能就是潜伏的木马。更抽象的问题是，许多用户为方便远程访问，将 OpenClaw 服务暴露在公网上，导致全球有数百个无防护的服务实例成了黑客的活靶子。

高昂的成本，聪明“大脑”的昂贵思考

我看到网上很多用户惊讶于使用 OpenClaw 时代理 API 的 Token 消耗速度。但这点我要为 OpenClaw 正名。这并不是 bug，因为其工作模式决定。你要完成复杂任务，它就需要进行多轮迭代式思考。例如，写一个程序时，它可能首先生成代码，然后运行测试，接着阅读错误日志，再生成修复方案。每一轮“思考-行动-观察”的循环，都需要将大量上下文（代码、错误信息、工具输出）重新发送给云端 AI，导致 Token 消耗急剧累积。它越智能、越自主，你的 API 账单就越能反映其“思考”的深与广度。

便利性与控制权的终极权衡

OpenClaw 无疑是一个震撼人心的技术演示，它让我们真切触摸到了高度自主化 AI 助理的未来。对于热衷探索的开发者，它是一个无与伦比的创新平台。但同时，它也是一个尖锐的警示。在我们急切地将权力下放给 AI 以求便利时，可能正在不经意间铸造系统中最脆弱的一环。使用它，就像在家中豢养一头能力超群但心性未定的野兽。你或许能享受它带来的无尽便捷，但也必须时刻准备承受其难以预测的行为所带来的风险。在完全拥抱它之前，每一位用户都应当问自己：我是否真的愿意，用整个数字世界的安全门锁，去交换一把名为“全能”的、尚未开刃的双刃剑？

“我已经好多天没和别人说过话了。”在人工智能技术飞速发展的今天，这样的大学生越来越多。他们通过“古早”的声音媒介——播客，找到了久违的“活人感”。—— 中工网《圈粉上亿年轻人 播客为啥这么火？》

播客这种形式曾经一度遇冷，如今却重新焕发生机。数据显示，2023年中文播客听众已达1.17亿，2024年预计增至1.34亿，2027年将突破 1.79 亿。—— 中工网《圈粉上亿年轻人 播客为啥这么火？》

什么是播客？

播客（Podcast）是一种基于互联网的数字广播形式，它允许内容创作者发布音频或视频节目，用户可以通过订阅的方式自动接收最新内容。其名称来源于苹果公司的“iPod”与“广播”（broadcast）的组合。与传统广播不同，播客内容可以随时下载或在线收听，适应现代人在通勤、运动等多种场景下的伴随性需求。它既可以是个人表达观点的“个人电台”，也涵盖专业媒体的深度节目，内容从知识分享到生活故事无所不包。近年来，凭借真实感和深度内容，播客尤其吸引了年轻高学历群体的喜爱，依我看它正在成为“抵抗算法运动”中连接创作者与听众的重要媒介。

播客的技术核心在于其订阅和自动分发机制，这使它不同于传统的实时广播或简单的音频下载。下面这个表格能帮你快速抓住几个关键技术环节的要点。

关键技术与优势

基于上述流程，播客技术的精髓主要体现在：

• 真正实现“订阅即自由”：用户一次订阅，即可自动接收所有后续更新，无需手动查找。这种基于 RSS Enclosure 的技术，将音频文件附件通过 RSS^[1] 推送，这是播客的技术基石。本站就有 RSS 推送功能，很多博友利用 RSS 实现诸多例如博客朋友圈的功能，这非常有趣。

• 与流媒体的核心区别：播客设计用于分发可下载的媒体文件，方便离线收听。虽然许多平台也提供流媒体播放，但可下载、可离线是播客的重要特性。

• 对所有人友好：播客技术对创作者和听众都很友好。创作者只需生成文件并更新 RSS，无需复杂服务器技术。听众订阅后，新内容会自动送达，非常省心。

播客技术新趋势

播客技术也在不断发展，近期播客突然的重回视野让我了解到，视频播客（Vodcast）正在逐渐大规模普及，其技术原理与音频播客完全相同，只是分发的文件形式从音频转变到了视频格式。

从数据中看播客复兴的现实

播客的复兴首先体现在数据上。中文播客听众规模已突破 1 亿大关，以高学历、高收入中青年为主，多分布在一线及新一线城市。这些听众中，女性占 51.8%，平均年龄 31.9 岁，本科及以上学历占 91.2%。青年群体成为播客的核心受众，18-35 岁用户占比超 83%。播客内容也呈现多元化趋势。从《纵横四海》的读书推荐，到《肥话连篇》的两性关系讨论，播客覆盖了生活的方方面面。众多的年轻听众表示，对于播客的累计收听时长已超过 500 小时。通勤路上、化妆护肤时、睡觉前，只要有空，他们便会戴上耳机沉浸其中。

对抗算法也寻求真实联结

在算法主导内容分发的时代，用户对“三秒抓眼球”的内容产生审美疲劳（央视新闻称之为“脑腐”）。人们开始渴望真实、深度、有思想的交流，而播客恰好填补了这一空白。三个月前我就在博客上发了一篇关于短视频信息茧房的文章《别被短视频吞噬你积极的人生》其中我就明确的写出：

平台的目标很明确：最大化用户停留时间。为此，它们构建了一套强大的“多巴胺陷阱”-引擎。

个性化推荐的背后，算法通过分析你的每一次停留、点赞、滑动，比你自己还了解你的偏好。它不断推送你“可能”感兴趣的内容，让你感到平台“懂你”，营造一种自主支配的错觉，实则将你引入“信息茧房”。
而无缝衔接的沉浸体验中让自动播放、无限下拉的设计，消除了任何需要你“选择”的停顿点。继续观看成为最不费力的路径，而停止观看则需要主动的意志力消耗。

如今播客重回大众视野，我很负责的说，这并不是意外走红，而是大家似乎都发现了。在注意力争夺这场战斗中，我们所面对的是算法工程师、心理学家和产品经理通力合作的成果，他们精准地拿捏了人类大脑的弱点。而我们似乎无法孤身战斗且赢得斗争，那最好的办法便是采用最原始的方案 —— 我不用，你便无法操控！

而作为产品，播客的核心魅力在于“活人感”与“真实感”。相比 AI 生成的内容和过度剪辑的短视频，播客保留了更多真实的人际链接，成为不那么公式化的内容载体。

播客爱好者飞星表示：“我只听真人主播的节目，AI 那种生硬的语气和断句，让人根本没有听下去的欲望。” 这种对真实的渴望，是播客能够打动年轻人的关键。

《忽左忽右》创始人程衍樑认为，播客强调订阅逻辑，与算法推荐形成鲜明对比。算法推荐弱化创作者、强调内容本身，而播客则以创作者为核心，听众因认可创作者而愿意花费时间收听。

在碎片化时代寻求完整表达

播客的“长内容”特性，是其吸引青年的核心优势之一。在高度碎片化的信息时代，播客成为许多人专注获取信息的“净土”。

播客的“长”并非生而有之。《忽左忽右》的另一位创始人杨一回忆，早年他们与平台打交道时，曾被建议将一小时节目切成三个20分钟的节目播出。这表明互联网曾一度向“短平快”的方向发展。但短内容解决不了所有问题。无论是个人主播还是品牌方，都需要更长的时间维度来传递核心观点。听众也存在消费长内容的潜在需求。程衍樑指出，长内容供给减少与用户长内容阅读能力下降，共同推动了播客的兴起。播客完美适配了深度爱好者的需求——既能以足够长的时间承载深度内容，又比文字内容门槛更低。

明星入局

2026 年，明星播客成为新热点。章泽天、杨天真、罗永浩等名人纷纷开设个人播客，推动播客从小众走向大众。

章泽天的《小天章》首期对话刘嘉玲，谈 60 岁的人生与孤独。没有剪辑、没有脚本，一段近一小时的真诚对话，3 小时内收听量突破 2.2 万。明星们通过播客重塑形象，从“流量明星”向“内容创作者”转型。

与此同时，播客正经历一场“视频化”转型。B 站、小红书、喜马拉雅等平台纷纷推出视频播客专区，内容既可听也可看。视频播客并非“音频+画面”的简单叠加，而是深度内容在媒介进化中的自然延伸。它既保留播客“长对话、深内容”的内核，又叠加视频的可视化优势。

商业化挑战与未来前景

尽管播客热度攀升，但商业化仍是挑战。一级市场依然处于谨慎观望状态，与平台和用户端的火热形成对比的是创作者们的“囊中羞涩”。

2025 年 4 月，头部播客《不合时宜》被曝拖欠实习生工资，其 2024 年全年净收入仅 13 万元。有媒体报道，仅有 20% 的播客创作者是全职投入，多数人因收入无法维生而难以坚持。

但商业化前景正在改善。2024 年购买付费播客节目、订阅付费专辑的金额显著上涨，61% 的受访主播表示收入较 2023 年有明显提高。

艾媒咨询 CEO 张毅认为，2026 年播客的核心方向是商业化的加速，产业链有望得到更好的整合提速。品牌定制、播客付费订阅、直播活动等方面可能出现高客单价的品牌合作。

本站播客订阅链接

本站新增加了播客订阅链接，我会将重要文章同步至 我的个人播客 欢迎大家订阅收听～

共用体的定义方式与结构体（struct）相似，但需要把关键字换成 union。例如，你可以定义一个包含整型、字符型和浮点型成员的共用体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
#include <cstring>

using namespace std;

union BasicData
{
    int integer_value;
    float float_value;
    char string_value[20];
};

int main()
{
    BasicData data;
    
    // 存储整数
    data.integer_value = 42;
    cout << "整数值: " << data.integer_value << endl;
    
    // 存储浮点数（会覆盖之前的整数）
    data.float_value = 3.14f;
    cout << "浮点数值: " << data.float_value << endl;
    
    // 存储字符串（会覆盖之前的浮点数）
    strcpy(data.string_value, "Hello, Union!");
    cout << "字符串值: " << data.string_value << endl;
    
    // 演示数据覆盖效果
    cout << "覆盖后尝试读取整数: " << data.integer_value << endl; // 无意义的值
    
    return 0;
}

然而，与结构体所有成员独立占用内存空间不同，共用体的所有成员都从相同的内存地址开始存储。因此，一个共用体变量所占用的总内存大小，由其最长的成员决定。例如，如果一个共用体包含一个 int（通常占 4 字节）和一个 double（通常占 8 字节），那么该共用体的大小就是 8 字节。这种内存共享机制也带来了一个关键特性：当你给一个成员赋值后，再给另一个成员赋值，就会覆盖之前的值，因为它们共享同一块内存。所以，在某一时刻，只有最后一次被赋值的成员是有效的。

1
2
3
4
5
6
7
8
9
10
11
12
13

// 存储整数
data.integer_value = 42;
cout << "整数值: " << data.integer_value << endl;

// 存储浮点数（会覆盖之前的整数）
data.float_value = 3.14f;
cout << "浮点数值: " << data.float_value << endl;

// 存储字符串（会覆盖之前的浮点数）
strcpy(data.string_value, "Hello, Union!");
cout << "字符串值: " << data.string_value << endl;

cout << "覆盖后尝试读取整数: " << data.integer_value << endl; // 无意义的值

由于共用体的这种特性，在使用时有几点需要特别注意。你不能直接对共用体中定义的变量名进行赋值或初始化，也不能用它作为函数参数或返回值，而只能通过其成员来访问数据。同时，共用体变量的地址和它各个成员的地址都是相同的。在 C++ 中，共用体可以像类一样拥有成员函数（如构造函数），但不能有虚函数、静态数据成员或引用成员，也不能作为基类使用（面向对象及类的知识我们会在第七章类与对象中讲到）。此外，如果共用体的成员是自定义类型（如某个类的对象），那么该类不能有构造函数、析构函数、重载的赋值运算符或虚函数。

共用体一个典型的应用场景是当某个数据项可能具有多种类型，但在一段时间内只会使用其中一种类型时，可以用来节省内存。例如，在一个商品管理结构中，有些商品的 ID 是整数，有些则是字符串，就可以使用共用体来存储 ID。共用体也常用于低级编程，如操作系统数据结构、硬件寄存器访问或需要直接处理数据字节的场景（例如类型转换或分离高低字节）。还有一种特殊的匿名共用体（anonymous union），它没有名称，其成员可以直接被外层结构体或类的成员访问，使得代码更加简洁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
using namespace std;

struct ConfigValue
{
    enum ValueType { INT_TYPE, FLOAT_TYPE } type; // 标签，用于指示当前存储的是哪种类型的数据
    union
    { // 匿名共用体
        int int_val;     // 当type为INT_TYPE时，使用此成员
        float float_val; // 当type为FLOAT_TYPE时，使用此成员
    }; // 匿名共用体结束，其成员int_val和float_val直接成为ConfigValue的成员
};

int main()
{
    ConfigValue cv;
    
    cv.type = ConfigValue::INT_TYPE;
    cv.int_val = 100; // 直接访问匿名共用体的成员，无需中间变量名
    cout << "Integer value: " << cv.int_val << endl;
    
    cv.type = ConfigValue::FLOAT_TYPE;
    cv.float_val = 3.14f; // 给float_val赋值会覆盖int_val的内存
    cout << "Float value: " << cv.float_val << endl;
    
    // 错误演示：由于内存共享，此时再读取cv.int_val将得到无意义的数据
    // cout << cv.int_val << endl;
    
    return 0;
}

在实际编程中，为了确保能正确解读共用体中存储的数据，通常需要另一个额外的变量，例如：enum ValueType { INT_TYPE, FLOAT_TYPE } type;（通常称为"标签"或"判别式"）来记录当前共用体中存储的是哪个成员。例如，在一个结构体中，可以有一个 type 字段指明当前应该使用共用体中的哪个成员。共用体的内存布局还会受到内存对齐规则的影响。编译器可能会在成员之间或共用体末尾添加填充字节，以确保数据在内存中的地址符合特定要求，从而优化访问速度。因此，共用体的实际大小可能不等于其最大成员的大小，而是其对齐要求的整数倍。

结构体是一种比数组更灵活的数据操作工具，因为同一个结构体可以存储多种数据类型的数据，这使得我们可以实现诸如上文提到的员工信息管理的效果，从而将同类信息当作一个集合来看待。我们甚至可以通过结构数组将整个企业的信息进行集合。结构体也是我们在学习第七章类与对象前的基石，通过这块垫脚石对我们进行铺垫后，我们将离 C++ 的核心内容面向对象编程（OOP）更近一步。

4.2.1 C++ 结构体的基本概念

结构体（struct）是 C++ 中一种用户自定义的数据类型，它允许将多个相关的数据项组合在一起，形成一个完整的逻辑实体。结构体可以包含各种类型的变量，这些变量称为成员变量，结构体提供了一种将相关数据封装在一起的方式，从而使数据管理变得更加高效和有序。

在 C 语言中，结构体只能包含数据成员，但在 C++ 中，结构体得到了极大的增强，它可以包含成员函数、构造函数、析构函数，甚至支持继承和多态等面向对象特性。这意味着结构体不仅可以存储数据，还可以由程序员自己定义操作这些数据的行为。例如，一个员工信息的结构体中可以包含计算员工工资的成员函数。这一增强使得数据和行为紧密的结合起来了，大大提高了代码的可读性和模块化程度。

结构体的定义使用 struct 关键字，后面跟着结构体的名称和一对花括号，花括号内包含成员变量的声明。结构体的定义通常放在头文件中或函数的顶部，以便在多个地方使用。定义结构体后，可以像使用内置类型一样使用它来声明变量。结构体实例的成员通过点运算符（.）^[1]访问，如果使用指针访问结构体成员，则使用箭头运算符（->）^[2]。结构体的这种特性使得它非常适合用于表示现实世界中的实体，学生、教师以及员工等，这些实体通常具有多个属性，结构体能够将这些属性有机地组织在一起。

4.2.2 结构体的定义与声明

在 C++ 中，结构体的定义是通过 struct 关键字实现的，这标志着一种新数据类型的创建。定义结构体时，需要指定其名称和成员列表，成员列表可以包含变量、函数甚至其他结构体。结构体的定义不仅描述了数据的组织方式，还定义了该类型变量的蓝图。

图 4-2-1   结构体的组成部分

结构体变量的创建有多种方式，每种方式都有其适用场景。最直接的方式是使用 struct 关键字后跟结构体名称和变量名，但 C++ 中创建结构体变量时 struct 键字可以省略，这使得代码更加简洁。另一种常见的方式是在定义结构体的同时创建变量，这种方式适用于需要立即使用结构体的情况。此外，还可以使用初始化列表或构造函数来创建结构体变量，这两种方式允许在创建变量时直接初始化成员的值。

• 下面我们通过一个具体的结构体定义来演示前三种创建方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
#include <cstring>  // 用于 strcpy 函数
using namespace std;

// 1. 先定义结构体类型
struct Employee
{
    int id;
    char name[50];
    int age;
    float salary;
};

int main()
{
    // 方式1：先定义后声明（C++ 中可省略 struct 关键字）
    Employee e1;    // 等同于 struct Employee s1;
    e1.id = 1001;
    strcpy(e1.name, "张三");
    e1.age = 28;
    e1.salary = 4200.72f;

    // 方式2：定义类型的同时声明变量
    struct Point
    {
        int x;
        int y;
    } p1, p2; // 此处同时创建了 p1 和 p2 两个变量

    p1.x = 10;
    p1.y = 20;

    // 方式3：使用初始化列表
    Employee e2 = {1002, "李四", 29, 4200.72f}; // 传统带 = 的写法
    Employee e3 {1003, "王五", 25, 4300.00f};   // C++11 起支持的省略=的写法

    return 0;
}

• 对于需要更复杂初始化逻辑的场景，可以为结构体定义构造函数。这属于面向对象编程的范畴，让结构体的使用更像一个"类"。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
using namespace std;

struct Employee
{
    int id;
    char name[50];
    int age;
    float salary;

    // 默认构造函数（无参数）
    Employee()
    {
        id = 0;
        strcpy(name, "未知");
        age = 0;
        salary = 0.0f;
    }

    // 带参数的构造函数，使用初始化列表
    Employee(int _id, const char* _name, int _age, float _score)
        : id(_id), age(_age), salary(_score)
    { // 初始化列表
        strcpy(name, _name);
    }

    // 可以定义多个构造函数（重载）
    Employee(int _id, const char* _name) : id(_id)
    {
        strcpy(name, _name);
        age = 18;   // 给年龄一个默认值
        salary = 4000.0f;
    }
};

int main()
{
    // 使用不同的构造函数创建结构体变量
    Employee s1; // 调用默认构造函数
    Employee s2(1001, "赵六", 20, 6000.5f); // 调用带四个参数的构造函数
    Employee s3(1002, "孙七");  // 调用带两个参数的构造函数

    return 0;
}

4.2.3 结构体的高级特性

结构体在 C++ 中不仅限于存储基本数据，还支持一系列高级特性，使其能够处理更复杂的数据结构和逻辑。结构体嵌套是其中之一，它允许在一个结构体中包含另一个结构体作为成员。这种特性使得程序能够更好地组织复杂的数据结构。例如，在一个表示教师的结构体中，可以嵌套一个表示学生的结构体，从而描述教师辅导学生的关系。嵌套结构体的成员通过多重点运算符访问，例如：teacher1.student.name，这种访问方式直观地反映了数据的层次结构。

结构体与数组的结合使用创造了结构体数组，它能够存储多个相同类型的结构体实例。结构体数组非常适合表示同类事物的集合，如多个点的坐标。通过数组索引，可以访问每个结构体实例，进而访问其成员变量。结构体数组使得批量处理相似数据变得简单，例如，可以使用循环遍历数组中的所有元素，对每个元素执行相同的操作。

结构体与指针的结合使用是 C++ 中的重要概念，可以通过指针高效地处理动态内存分配的结构体。使用指针访问结构体成员时，需要使用箭头运算符（->），这简化了通过指针访问成员的操作。结构体指针特别适合用于动态内存分配，例如使用 new 关键字在堆上创建结构体实例，这种方式允许手动控制结构体的生命周期。此外，结构体还可以作为函数参数传递，传递方式包括值传递、引用传递和指针传递。值传递会创建结构体的副本，适合保护原始数据；引用传递和指针传递则避免复制开销，允许函数修改原始结构体。通过 const 关键字，可以防止函数意外修改结构体内容，进一步提高代码的安全性。

4.2.4 结构体与类的区别及选择

在 C++ 中，结构体（struct）和类（class）是两种相似但又有区别的用户自定义数据类型。它们最大的区别在于访问控制的默认设置：结构体的成员默认是公有的（public），而类的成员默认是私有的（private）。这代表在结构体中，除非显式指定，否则所有成员都可以从外部直接访问；而在类中，成员通常被封装起来，只能通过公有成员函数访问。这一区别反映了结构体和类在设计哲学上的差异：结构体强调数据的透明访问，而类强调数据的封装和行为。

另一个重要区别体现在继承的默认方式上。当结构体用于继承时，默认的继承方式是公有继承，而类则默认为私有继承。这意味着从结构体派生的新结构体会自动继承基结构体的所有公有成员，而从类派生的新类则会继承基类的私有成员（但访问受限）。这一区别使得结构体更适合实现简单的数据层次结构，而类则更适合构建复杂的继承体系。

在选择使用结构体还是类时，需要考虑数据的特性和使用场景。结构体适合用于主要包含数据成员、行为简单的场景，如坐标点、颜色值或数据库记录。结构体的默认公有访问使得数据操作直接明了，适合数据导向的设计。类则适合需要复杂逻辑、严格封装和多态行为的场景，如游戏角色、银行账户等实体。类通过隐藏实现细节，提供了更好的封装性和可维护性。在实际编程中，选择结构体还是类取决于具体需求，但理解它们的区别有助于做出更合理的设计决策。

4.2.5 结构体的内存布局与性能考虑

构体在内存中的布局方式直接影响程序的性能和内存使用效率。结构体的成员在内存中是连续存储的，所有成员变量紧密排列。这种连续性使得访问结构体成员时效率较高，因为相邻成员可能位于同一缓存行中，减少了缓存未命中的概率。然而，这种连续存储也带来了内存对齐的问题，即成员变量需要存储在特定地址边界上，以满足硬件访问要求。

内存对齐是编译器为了优化内存访问速度而采取的一种策略。对齐规则要求每个成员变量存储在自身大小整数倍的地址上。例如：一个 4 字节的 int 变量需要存储在 4 的整数倍地址上。为了满足对齐要求，编译器可能在成员之间插入填充字节，这会增加结构体的总大小。结构体的总大小通常是最大成员对齐数的整数倍，这意味着即使所有成员的总和小于这个值，结构体也会占用对齐后的完整空间。

为了优化结构体的内存布局，可以采取一些策略。例如，按照成员类型的大小降序排列成员，将较大的数据类型放在前面，较小的放在后面，这样可以减少填充字节的数量。另外，对于频繁传递的结构体，可以考虑使用引用或指针来避免拷贝开销。

4.2.6 结构体总结

C++ 结构体是一个功能强大且灵活的数据组织工具，它融合了 C 语言中结构体的简洁性和 C++ 面向对象编程的强大特性。从基本的数据封装到高级的面向对象特性，结构体为程序员提供了一种有效管理复杂数据的方式。通过结构体，我们可以创建更加符合问题域概念的数据结构，提高代码的可读性、可维护性和重用性。结构体与类的区别使得它们各有适用的场景：结构体适合数据透明、行为简单的场合，而类适合封装复杂、行为丰富的对象。

在现代 C++ 编程中，结构体的应用范围不断扩大，从简单的数据容器到复杂的系统接口，处处可见其身影。随着 C++ 标准的演进，结构体的功能也在不断增强，如列表初始化、默认成员初始化等特性使得结构体的使用更加方便和安全。理解结构体的内存布局和对齐机制有助于编写出高效且节省内存的代码。无论是初学者还是经验丰富的程序员，掌握结构体的各种特性和应用场景都是提高 C++ 编程水平的关键。

要创建数组，可以使用声明语句。数组的声明应该正确的指出三点，数据的类型、数组名称以及数组中的元素个数。其中数组中的元素个数必须是正整数常数^[1]。例如：

1

数据类型 数组名[数组大小];

例如，声明一个可以存放 5 个整数的数组：

1

int numbers[5];

这里，int 是数组元素的类型，numbers 是数组的名称，5 是数组的大小，表示这个数组可以存放 5 个整数。事实上，我们可以将数组中的每个元素看作是一个简单变量。

4.1.1 初始化数组

C++ 初始化数组有几条规则，他们限制了初始化的时刻，决定了数组元素数目与初始化器中值的数目不相同时将发生的情况。

只有在定义数组时才能使用初始化，此后就不能再初始化了，也不能将一个数组赋给另外一个数组（但可以使用索引分别给数组元素赋值）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 允许
int arr1[3] = {0, 1, 2};

// 允许
int arr2[3];

// 允许
int number = 2;
int arr3[3];
arr3[3] = number;

// 不允许
int arr4[3];
arr4[3] = {0, 1, 2} 

// 不允许
arr1 = arr2;

有几种常见的初始化数组的方式：

全部初始化：在声明数组时，为所有元素提供初始值。

1

int numbers[5] = {1, 2, 3, 4, 5};

部分初始化：只提供部分元素的初始值，剩下的元素会自动初始化为 0。

1

int numbers[5] = {1, 2};

此时，numbers[0] 为 1，numbers[1] 为 2，而 numbers[2]、numbers[3]、numbers[4] 都为 0。

省略数组大小：如果在初始化时提供了所有元素的值，可以省略数组大小，编译器会根据初始化的值的数量来确定数组的大小。

1

int numbers[] = {1, 2, 3, 4, 5};

这里，数组 numbers 的大小会被编译器自动确定为 5。

4.1.2 访问数组元素

程序代码4-1（酒店房间预订程序）中说明了数组的一些属性，包括初始化数组、声明数组以及给数组元素赋值。

1

condition ? expression1 : expression2;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>
using namespace std;

int main()
{
    // 定义布尔数组来表示 3 个房间的使用状态，初始都为空闲
    bool roomStatus[3] = {false, false, false};

    // 显示房间初始状态
    cout << "房间 1：" << (roomStatus[0] ? "已使用" : "空闲") << endl;
    cout << "房间 2：" << (roomStatus[1] ? "已使用" : "空闲") << endl;
    cout << "房间 3：" << (roomStatus[2] ? "已使用" : "空闲") << endl;

    // 模拟预订房间 2
    roomStatus[1] = true;

    // 显示房间更新后的状态
    cout << "\n更新后：" << endl;
    cout << "房间 1：" << (roomStatus[0] ? "已使用" : "空闲") << endl;
    cout << "房间 2：" << (roomStatus[1] ? "已使用" : "空闲") << endl;
    cout << "房间 3：" << (roomStatus[2] ? "已使用" : "空闲") << endl;

    return 0;
}

下面是程序的运行结果：

1
2
3
4
5
6
7
8

房间 1：空闲
房间 2：空闲
房间 3：空闲

更新后：
房间 1：空闲
房间 2：已使用
房间 3：空闲

图 4-1-1   数组下标

数组的索引是从 0 开始的。也就是说，对于一个大小为 n 的数组，合法的索引范围是从 0 到 n - 1。例如程序代码4-1（酒店房间预订程序）中我们使用 roomStatus[1] = true; 语句将房间 2 由空闲变为已使用状态。你可以像使用普通变量一样使用数组元素，比如进行赋值、计算等操作。

4.1.3 多维数组

除了一维数组，还有多维数组，最常见的是二维数组。二维数组可以想象成一个表格，有行和列。声明二维数组的格式如下：

1

数据类型 数组名[行数][列数];

例如，我们声明一个 5 行 4 列的整数二维数组，并使其初始化：

1
2
3
4
5
6
7
8
9
10
11
12

//声明一个二维数组
int matrix[5][4];

//对二维数组进行初始化
int matrix[5][4] =
{
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    {13, 14, 15, 16}
    {17, 18, 19, 20}
};

访问二维数组的元素需要指定行索引和列索引，例如 matrix[1][2] 表示第二行第三列的元素，值为 7。

4.1.4 数组的替代品

C++ 标准模板库（STL）中有一种数组的替代品—— vector，它比复合类型数组更复杂也更灵活，好虽好但也请不要着急，我们还在后续章节向你详细介绍 STL 和 模板类 vector。

1
2

int array[] = {0, 1, 2, 3, 4, 5};
int num_elements = sizeof array / sizeof(array);

• 如何创建和使用数组；
• 如何创建和使用 C 风格的字符串；
• 如何创建和使用 string 类的字符串；
• 如何混合输入字符串和数字；
• 如何使用 getline() 和 get() 方法来读取字符串；
• 如何创建和使用结构；
• 如何创建和使用共用体；
• 如何创建和使用枚举；
• 如何创建和使用指针；
• 如何管理动态内存；
• 如何创建和使用动态数组；
• 如何创建动态结构；
• 了解自动存储、静态存储和动态存储。

嘿，恭喜你，一路披荆斩棘的离开了数据操作的奇妙森林，很高兴看到你用基本数据类型和各种运算符玩得那叫一个不亦乐乎，就像熟练的厨师在厨房里摆弄着锅碗瓢盆，做出了一道道简单却美味的数据“菜肴”。

但请不要以为编程的冒险就到此为止啦！现在，咱们要一脚迈进第 4 章复合类型这个神秘又刺激的全新世界。如果说第 3 章的基本数据类型是一个个孤零零的小士兵，那这章的复合类型就是由它们组成的强大军团，有能批量收纳数据的数组“大仓库”，有像超级导航一样精准定位的指针，还有和变量亲密无间的引用“好兄弟”。

更厉害的是，这里还有 new 和 delete 这对神奇搭档，能像魔法师一样在程序运行时随意召唤和遣散内存空间，打造出各种动态结构和数组。这就好比咱们从操控小士兵升级成了指挥千军万马的大将军，能构建出更加宏伟壮观的编程城堡！

准备好了吗？让咱们一起撸起袖子，在复合类型的世界里大干一场，创造出属于咱们的编程传奇！

再瞧瞧浮点类型，这就像是一群调皮的魔法师，能表示带小数的数值。不过呢，它们也有点小脾气，在运算的时候容易产生舍入误差，就像魔法师偶尔也会念错咒语一样，所以和它们打交道可得多留个心眼。

算术操作符就像是神奇的魔法棒，+、-、*、/、% 这些符号一挥，数据就能进行各种奇妙的变化。但它们也有自己的“江湖规矩”，优先级和结合性就是它们的“辈分”和“规矩”，可不能乱了套。

操作符重载更像是一场创意十足的变装派对，我们可以为自定义类型重新设计操作符的行为，让它们也能像内置类型一样在派对上欢快地“跳舞”。不过，可不能玩得太疯，得遵循操作符的原有“风格”，不然派对可就乱成一锅粥。

最后，类型转换就像是一个神奇的“变形金刚”，能让数据在不同的形态之间自由转换。隐式类型转换就像偷偷摸摸的小变身，编译器会自动帮我们完成；而显式类型转换则像是一场盛大的公开表演，需要我们亲自指定转换的类型。

掌握了这些知识，咱就像拥有了一把万能钥匙，能更加灵活地打开不同类型数据的“宝箱”，编写出高效、安全又好维护的 C++ 程序。在实际编程的江湖里闯荡时，可得根据具体的“战斗需求”，挑选合适的数据类型、操作符和类型转换方式，时刻留意各种操作里的小陷阱，比如浮点运算的误差、操作符重载的合理性，不然一不小心就会掉进“坑”里，摔得鼻青脸肿哟！

章节阅读提示

在学习 C++ 的过程中，衰变复制（Decay Copy）是一个与语言最新发展密切相关的进阶特性。它作为 C++ 23 引入的新特性，结合了类型推导、模板编程和值语义等多项复杂概念。建议初学 C++ 的读者将本小节作为日后工作中的工具文献阅读，在初学阶段你大可不必理会本小节。以下为系统性学习建议：

现阶段建议
目前先跳过衰变复制这部分内容的学习。因为衰变复制涉及到 std::decay 类型特性、auto 关键字的高级用法、值类别（左值/右值）等较为深入的知识，需要一定的基础才能完全理解。而你当前的知识储备可能还不足以完全掌握它。过早接触可能会让你感到困惑，影响学习的积极性和效果。

后续学习指引
当你完成以下几个关键部分的学习后，就可以返回阅读操作符重载这一小节了：

1. C++ 模板基础
2. auto 关键字
3. 值类别（Value Categories）
4. 拷贝构造函数与移动构造函数
5. 标准库类型特性

当你完成上述内容的学习后，你将具备足够的知识基础来深入学习衰变复制。此时再返回阅读衰变复制这部分内容，你会发现理解起来更加轻松，也能更好地掌握这一 C++ 新特性。

C++23 中引入的衰变复制 (Decay Copy) 是一个旨在简化对象副本创建过程的语言特性。它通过 auto(x) 和 auto{x} 这两种新语法，为开发者提供了一种更为简洁和安全的方式来生成对象的右值副本，尤其在模板编程和并发编程中非常有用。

3.9.1 什么是衰变复制

你可以将衰变复制理解为是一种组合操作，它主要包含两个连续的步骤：

1. 第一步是类型衰变。这一步借鉴了 C++ 模板中对传值参数进行类型推导的规则，它会处理掉类型中的引用限定符（& 和 &&）以及顶层的 const/volatile 限定符。同时，它也会将数组类型转换为对应的指针类型，将函数类型转换为函数指针类型。例如，const char 会衰变为 const char*，int (&)() 会衰变为 int (*)()。
2. 第二步是创建副本。在类型衰变之后，会基于衰变后的类型创建一个新的对象副本。如果原始表达式是左值，则调用拷贝构造函数；如果是右值，则优先调用移动构造函数。最终，auto(x) 或 auto{x} 表达式会产生一个纯右值，代表这个新创建的临时对象。

3.9.2 为什么需要衰变复制

在 C++23 引入衰变复制之前，在泛型代码中安全、高效地创建一个对象的副本有时会有些棘手。首先，当你在模板函数中，面对一个由模板参数推导出的复杂类型 T，想要声明一个该类型的变量来存储副本，类型书写可能很繁琐，甚至可能因为类型不匹配而导致错误。

其次，有些类的拷贝构造函数被声明为 explicit。这意味着你不能直接使用类似 T copy = original; 的语法进行拷贝初始化，这增加了代码编写的难度。

此外，在 C++11 标准制定过程中，标准库工作组遇到了一个具体问题。例如，在使用 std::thread 构造函数并传递字符串字面量时，字符串字面量的类型是数组（例如 const char），而数组是不可复制、不可移动的，这会导致编译错误。虽然可以通过将参数改为传值方式利用类型衰变来解决匹配问题，但又可能引入不必要的性能开销。衰变复制的概念正是为了优雅地解决这类问题而提出的。

3.9.3 衰变复制的语法和应用场景

在 C++23 中，衰变复制通过 auto(x) 和 auto{x} 表达式实现。这两种语法形式在功能上是完全等价的，它们都会执行衰变复制并生成一个右值副本。选择使用圆括号 auto(x) 还是花括号 auto{x}，通常可以根据个人或团队的编码风格来决定，花括号初始化一般能提供更严格的类型检查。

需要特别注意的是，auto 在这里的用法与变量声明中的类型推导不同。auto(x) 是一个独立的表达式，它可以在任何需要表达式的地方使用，其含义是“创建 x 的一个衰变副本”

模板编程中的副本创建

在模板函数中，当你需要创建一个参数的副本而又不确切知道或不关心其具体类型时，auto(x) 非常有用。它简化了代码，也避免了因类型书写错误而可能带来的问题。

1
2
3
4
5
6
7

template<typename T>
void processValue(T&& param)
{
    // 使用 auto(param) 创建 param 的衰变副本
    auto decayed_copy = auto(param);
    // ... 对 decayed_copy 进行操作，不会影响原始 param
}

避免容器操作导致的引用失效

在处理容器时，如果你持有了容器中某个元素的引用，随后对容器进行了修改操作，这个引用可能会失效。使用 auto(x) 可以先创建元素的副本，从而安全地操作。

1
2
3
4
5
6
7
8
9
10

template<typename Container>
void safeModificationTest(Container& c)
{
    if (!c.empty())
    {
        auto element_copy = auto(c.front());    // 创建首元素副本
        c.clear();                              // 即使清空容器，副本仍然有效
        // 可以安全地使用 element_copy
    }
}

并发编程中传递参数

在启动新线程时，需要确保传递给线程函数的参数是独立的副本，以避免数据竞争。auto(x) 可以明确地表示创建副本。

1
2
3
4
5
6
7
8

void backgroundTaskTest(const std::string& data)
{
    // 明确创建 data 的副本传递给新线程
    std::jthread worker([](std::string safe_data)
    {
        // 在新线程中安全地使用 safe_data
    }, auto(data)); // 使用 auto(data) 创建副本
}

需要纯右值的上下文

在某些时候，例如 return 语句或需要将对象作为纯右值传递时，auto(x) 可以方便地生成所需的表达式。

1
2
3
4
5
6
7
8
9
10
11

class Widget
{
    std::vector<int> data;

public:
    // 返回 data 的衰变副本（右值）
    auto getDataCopy() const
    {
        return auto(data);
    }
};

3.9.4 性能影响

虽然衰变复制带来了便利，但我们也需要关注其性能影响。

最核心的一点是，auto(x) 在 x 本身已经是一个纯右值（prvalue）时，编译器可能会进行优化，避免产生不必要的复制操作。然而，如果 x 是左值，则确实会发生一次拷贝操作。因此，在性能敏感的代码中，需要谨慎使用，你需要确保副本的创建是绝对必要的。

与传统的显式写类型创建副本（如 T copy = original; ）或使用 std::decay 结合 decltype 的方式相比，auto(x) 在语法上更加简洁直观，并且可能带来更好的优化机会。

在 C++ 11 之前的版本中，定义变量或者声明变量之前都必须指明它的类型，但在 C++ 11 中，编译器可以自主去介入推导类型了，这就使得 C++ 的代码编写更加方便和安全。在之前的 C++ 版本中，auto 关键字用来存储类型说明符，显式声明变量的存储期，这其实相当冗余鸡肋。因为局部变量^[1]默认就是自动存储期，显式添加 auto(auto int a) 与直接写 int a 本质上没有任何区别。由于是默认行为，显式声明就显得有点多此一举了。

而 C++11 移除了 auto 关键字自动存储期的含义，并赋予 auto 关键字新的作用 —— 自动类型推导。也就是说，使用了 auto 关键字以后，编译器会在编译期间自动推导出变量的类型，这样我们就不需要手动指明变量的数据类型了。下面是一个简单的示例：

1
2
3
4

auto a = 20;                            // a 是 int 类型
auto b = 20.25;                         // b 是 double 类型
auto c = 1.9L;                          // c 是 long double 类型
auto d = "https://blog.yujiay.wang/";   // d 是 const char* 类型, which is the author's blog homepage URL

• 第 1 行中：20 是一个整数，默认是 int 类型，所以推导出来的变量 a 类型是 int 型；
• 第 2 行中：20.25 是一个小数，默认是 double 类型，所以推导出来的变量 b 类型是 double 型；
• 第 3 行中：1.9L 是一个小数，后缀 L 表示 long double 类型，所以推导出来的变量 c 类型是 long double 型；
• 第 4 行中：“https://blog.yujiay.wang/” 是一个字符串字面量，在 C++ 中类型是 const char*^[2]，所以推导出来的变量 d 类型是 const char* 型；

介绍到这里，肯定有同学想了，auto 太棒了，不需要在人为再去记忆那么多复杂的类型了，一个 auto 不就可以搞定一切了吗？错的同学错的。自动类型推导并不是为了这种简单情况而设计的，让你心寒了。事实上，如果将其用于这种简单的情况，反而可能得不偿失。例如，你需要将某一人的身高（单位为厘米）存为 double 类型，以便后续程序中与米制单位进行转换，你使用了如下代码：

1

auto height = 183;

程序将直接将 height 变量推导成 int 类型的 183，而不是我们期待的 double 183.0 。显式的声明类型时，将变量初始化为 double 183 不会造成任何问题，但自动类型推导可能会造成难以排查大问题便得不偿失。

auto 只有在处理复杂类型时，比如用来定义标准模板库（STL）中的迭代器时（标准模板库及迭代器会在第十四章进行详细介绍，这里只是为了演示 auto 关键字的正确使用时机，不必死磕代码），需要使用迭代器遍历容器中的元素，不同容器的迭代器有不同的类型，在定义迭代器时必须要指明。而迭代器的类型有时候比较复杂，书写起来也很麻烦，我们便可以借助自动类型推导进行简化。

1
2
3
4
5
6
7
8
9

#include <vector>
using namespace std;

int main()
{
    vector<vector<int>> v;
    vector<vector<int>>::iterator i = v.begin();
    return 0;
}

不难发现，定义迭代器 i 时，类型写起来很长，而且还容易出错，但是借助 auto 自动类型推导，我们可以进行重写，让其更简洁：

1
2
3
4
5
6
7
8
9

#include <vector>
using namespace std;

int main()
{
    vector<vector<int>> v;
    auto i = v.begin();     // 使用 auto 关键字进行自动类型推导
    return 0;
}

通过以上学习，相信你已经掌握了 auto 自动类型推导，在后续的学习过程中，我们会带领大家通过 auto 关键字优化我们的程序。

1.页脚添加备案号

1.0 效果图

1.1 添加 _config.yml 字段

在博客根目录 Hexo 的配置文件(_config.yml)中添加如下新键值（这里要注意，是 Hexo 的配置文件，不是安知鱼主题的配置文件！）：

1
2
3

#建议添加在 timezone 下面，你也可以添加在其他位置
icp: 填写 ICP 备案号
gb: 填写公网安备号

1.2 添加、引用 CSS

完成了第 1 步后我们需要为页脚容器进行样式定义。在博客的 /source/ 目录中的 css 文件夹中创建一个名为 coustom.css 的文件（如果你没有 css 文件夹可以自行创建一个）。

在新建的 custom.css 文件中添加如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

/*============================= 页脚备案容器开始 blog.yujiay.wang =============================*/

/* 为 #footer-bar 设置相对定位，作为备案容器的定位参考 */
#footer-bar {
    /* 为备案信息预留更多空间 */
    min-height: 100px;
    /* 底部内边距，确保有足够空间 */
    padding-bottom: 50px;
}

/* 备案链接容器样式 - 使用ID选择器 */
#beian-links {
    /* 定位样式 - 绝对定位在 footer-bar 底部居中 */
    position: absolute;
    bottom: 15px;
    left: 50%;
    transform: translateX(-50%);

    /* 文本和布局样式 */
    display: block;
    width: auto;
    text-align: center;
    white-space: nowrap;

    /* 字体样式 */
    font-size: 12px;
    color: var(--anzhiyu-fontcolor);
    line-height: 1.5;
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    
    /* 确保在最上层 */
    z-index: 10;
}

/* 备案链接的样式 */
#beian-links a.footer-bar-link {
    color: var(--anzhiyu-fontcolor); /* 链接文字也设置为深色 */
    text-decoration: none;
    transition: color 0.3s ease; /* 添加过渡效果 */
}

#beian-links a.footer-bar-link:hover {
    text-decoration: none;
    color: var(--anzhiyu-lighttext); /* 悬停颜色 */
}

/* 移动端适配 */
@media (max-width: 768px) {
    #beian-links {
        margin: -30px 0;
        font-size: 11px;
        white-space: normal; /* 允许内容换行 */
        text-align: center; /* 确保换行后内容依然居中 */
        max-width: 90%;
        bottom: 10px;
        /* 使整个容器在移动端独占一行，居中效果更稳定 */
        display: block;
    }
    
    #beian-links a.footer-bar-link {
        display: inline-block;
        line-height: 1.8;
        padding: 2px 4px;
        /* 单独成行，可以设置为 block，并赋予宽度或使用其他布局 */
        /* display: block; */
    }

     /* 移动端适配链接样式 */
    #beian-links .separator {
            display: none !important; /* 上下排列时隐藏竖线分隔符 */
        }
    
}

/* 暗色模式适配 */
[data-theme="dark"] #beian-links a.footer-bar-link {
    color: var(--anzhiyu-fontcolor);;
}

[data-theme="dark"] #beian-links a.footer-bar-link:hover {
    color: var(--anzhiyu-lighttext);
    text-decoration: none;
}

/* 竖线分隔符样式 */
#beian-links .separator {
    color: #CCCCCC;
    margin: 0 10px;
    display: inline-block;
}

/* 暗色模式竖线适配 */
[data-theme="dark"] #beian-links .separator {
    color: #666666;
}

/*============================= 页脚备案容器结束 blog.yujiay.wang =============================*/

添加好后记得保存修改的文件。此外还需要在安知鱼主题的配置文件 inject -> head 处进行自定义 css 的引入工作：

1

- <link rel="stylesheet" href="/css/custom.css">

1.3 修改 footer.pug 文件

紧接着我们需要修改模板引擎，这里特别要注意缩进，Pug 的缩进至关重要，它直接决定了代码能否正确运行以及最终生成的HTML结构。如果你不确定缩进是否正确，最简单的办法，就是在 footer.pug 代码的最底部回车两个空行，然后将输入光标删除到最前端（没有缩进）的地方，复制下面的代码，然后将代码的第一行 #footer-wrap 删除掉。删除掉后不要动下面的代码，直接将空行全部删除即可。

1
2
3
4
5
6
7
8
9

#footer-wrap    // 这行最后一定要删除
    #beian-links
        a.footer-bar-link(href="#修改为你的链接" target="_blank" rel="nofollow noopener")
            img.beian-icon(src="#修改为你的图片" alt="公网安备图标" style="width: 14px; height: 14px; vertical-align: -2px; margin-right: 4px;")
            | #{config.gb}
        span.separator ｜
        a.footer-bar-link(href="https://beian.miit.gov.cn/" target="_blank" rel="nofollow noopener")
            img.beian-icon(src="#修改为你的图片" alt="备案图标" style="width: 14px; height: 14px; vertical-align: -2px; margin-right: 4px;")
        | #{config.icp}

处理好缩进后我们需要将代码中的链接、图片链接进行替换，替换成为你自己的链接和图片，替换后保存。

1.4 结束语

最后 Hexo 三连（hexo cl && hexo g && hexo s）就可以在页面底部查看效果了，这个 css 进行了响应式适配，移动端也可以很好的展示。

2.添加边栏日历卡片（单卡片风格）

好久不见，I’m back，前段时间去海南出了趟差，又正好赶上大学生们的期末周，手上单子也比较多，没顾得上更新本文，今天终于忙里偷闲，回来更新一下。

今天给大家带来一个我很喜欢的边栏卡片，这个卡片我最早是借鉴一个博主的（但时间太久我找不到他的原文了，希望看到能评论一下，我会链接到原文，感谢这位匿名博主）。网上有很多日历小卡片，但我发现它们都是把 css 单拎出来了，这样我们就需要修改 js、css、yaml and config 四个文件了，但这次介绍这个方法只需要修改三个文件，他将 js 和 css 写到一块了，对于我来说极大的降低了维护成本，而且他的这个风格也很简约。我现在将这个方案分享给大家。

2.0 效果图

2.1 添加、引用 JavaScript

首先我们需要为日历卡片进行样式逻辑实现和样式定义。在博客的 /source/ 目录中的 js 文件夹中创建一个名为 countdown.js 的文件（如果你没有 js 文件夹可以自行创建一个）。

在新建的 countdown.js 文件中添加以下代码（含样式实现，无需另外添加新 css 文件）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

const CountdownTimer = (() => {
    const config = {
        targetDate: "2026-02-17", /* 这里记得每年更新春节日期 */
        targetName: "春节",
        units: {
            day: { text: "今日", unit: "小时" },
            week: { text: "本周", unit: "天" },
            month: { text: "本月", unit: "天" },
            year: { text: "本年", unit: "天" }
        }
    };

    const calculators = {
        day: () => {
            const hours = new Date().getHours();
            return {
                remaining: 24 - hours,
                percentage: (hours / 24) * 100
            };
        },
        week: () => {
            const day = new Date().getDay();
            const passed = day === 0 ? 6 : day - 1;
            return {
                remaining: 6 - passed,
                percentage: ((passed + 1) / 7) * 100
            };
        },
        month: () => {
            const now = new Date();
            const total = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
            const passed = now.getDate() - 1;
            return {
                remaining: total - passed,
                percentage: (passed / total) * 100
            };
        },
        year: () => {
            const now = new Date();
            const start = new Date(now.getFullYear(), 0, 1);
            const total = 365 + (now.getFullYear() % 4 === 0 ? 1 : 0);
            const passed = Math.floor((now - start) / 86400000);
            return {
                remaining: total - passed,
                percentage: (passed / total) * 100
            };
        }
    };

    function updateCountdown() {
        const elements = ['eventName', 'eventDate', 'daysUntil', 'countRight']
            .map(id => document.getElementById(id));

        if (elements.some(el => !el)) return;

        const [eventName, eventDate, daysUntil, countRight] = elements;
        const now = new Date();
        const target = new Date(config.targetDate);

        eventName.textContent = config.targetName;
        eventDate.textContent = config.targetDate;
        daysUntil.textContent = Math.round((target - now.setHours(0,0,0,0)) / 86400000);

        countRight.innerHTML = Object.entries(config.units)
            .map(([key, {text, unit}]) => {
                const {remaining, percentage} = calculators[key]();
                return `
                    <div class="cd-count-item">
                        <div class="cd-item-name">${text}</div>
                        <div class="cd-item-progress">
                            <div class="cd-progress-bar" style="width: ${percentage}%; opacity: ${percentage/100}"></div>
                            <span class="cd-percentage ${percentage >= 46 ? 'cd-many' : ''}">${percentage.toFixed(2)}%</span>
                            <span class="cd-remaining ${percentage >= 60 ? 'cd-many' : ''}">
                                <span class="cd-tip">还剩</span>${remaining}<span class="cd-tip">${unit}</span>
                            </span>
                        </div>
                    </div>
                `;
            }).join('');
    }

    function injectStyles() {
        const styles = `
            .card-countdown .item-content {
                display: flex;
            }
            .cd-count-left {
                position: relative;
                display: flex;
                flex-direction: column;
                margin-right: 0.8rem;
                line-height: 1.5;
                align-items: center;
                justify-content: center;
            }
            .cd-count-left .cd-text {
                font-size: 14px;
            }
            .cd-count-left .cd-name {
                font-weight: bold;
                font-size: 18px;
            }
            .cd-count-left .cd-time {
                font-size: 30px;
                font-weight: bold;
                color: var(--anzhiyu-main);
            }
            .cd-count-left .cd-date {
                font-size: 12px;
                opacity: 0.6;
            }
            .cd-count-left::after {
                content: "";
                position: absolute;
                right: -0.8rem;
                width: 2px;
                height: 80%;
                background-color: var(--anzhiyu-main);
                opacity: 0.5;
            }
            .cd-count-right {
                flex: 1;
                margin-left: .8rem;
                display: flex;
                flex-direction: column;
                justify-content: space-between;
            }
            .cd-count-item {
                display: flex;
                flex-direction: row;
                align-items: center;
                height: 24px;
            }
            .cd-item-name {
                font-size: 14px;
                margin-right: 0.8rem;
                white-space: nowrap;
            }
            .cd-item-progress {
                position: relative;
                display: flex;
                flex-direction: row;
                align-items: center;
                justify-content: space-between;
                height: 100%;
                width: 100%;
                border-radius: 8px;
                background-color: var(--anzhiyu-background);
                overflow: hidden;
            }
            .cd-progress-bar {
                height: 100%;
                border-radius: 8px;
                background-color: var(--anzhiyu-main);
            }
            .cd-percentage,
            .cd-remaining {
                position: absolute;
                font-size: 12px;
                margin: 0 6px;
                transition: opacity 0.3s ease-in-out, transform 0.3s ease-in-out;
            }
            .cd-many {
                color: #fff;
            }
            .cd-remaining {
                opacity: 0;
                transform: translateX(10px);
            }
            .card-countdown .item-content:hover .cd-remaining {
                transform: translateX(0);
                opacity: 1;
            }
            .card-countdown .item-content:hover .cd-percentage {
                transform: translateX(-10px);
                opacity: 0;
            }
        `;

        const styleSheet = document.createElement("style");
        styleSheet.textContent = styles;
        document.head.appendChild(styleSheet);
    }

    let timer;
    const start = () => {
        injectStyles();
        updateCountdown();
        timer = setInterval(updateCountdown, 600000);
    };

    ['pjax:complete', 'DOMContentLoaded'].forEach(event => document.addEventListener(event, start));
    document.addEventListener('pjax:send', () => timer && clearInterval(timer));

    return { start, stop: () => timer && clearInterval(timer) };
})();

添加好后记得保存修改的文件。此外还需要在安知鱼主题的配置文件 inject -> bottom 处进行自定义 js 的引入工作：

1

- <script src="/js/countdown.js"></script>

2.2 添加 widget.yml 文件

完成了步骤 2.1 后我们来为小卡片添加 html 倒计时器组件。在博客的 /source/ 目录中的 _data 文件夹中创建一个名为 widget.yml 的文件（_data 文件夹是一个数据存储目录，用来存放网站的各种结构化数据。同上，如果你没有 _data 文件夹可以自行创建一个）。目录和文件创建好后，在 widget.yml 文件中添加以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

top:
  - class_name: card-countdown
    id_name:
    name:
    icon:
    html: |
      <div class="cd-count-left">
        <span class="cd-text">距离</span>
        <span class="cd-name" id="eventName"></span>
        <span class="cd-time" id="daysUntil"></span>
        <span class="cd-date" id="eventDate"></span>
      </div>
      <div id="countRight" class="cd-count-right"></div>

1.3 结束语

最后 Hexo 三连（hexo cl && hexo g && hexo s）就可以在页面侧边栏查看效果了。

但值得注意的是，步骤 2.1 中的 targetDate: "2026-02-17", 这部分（第 3 行）js 代码每年需要手动更新一下日期，如果忘记更新的话，年月日倒计时功能不受影响，只是距离春节天数会变为负数。

最后最后，欢迎大家在评论区给予指正，让我们共同打造快节奏时代不受算法牵制的属于我们自己的小空间！

3.7.1 隐式类型转换

隐式类型转换也称为自动类型转换，是由编译器自动完成的，不需要程序员手动干预。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <iostream>

// 定义一个函数，用于打印整数
void printNumber(int num)
{
    std::cout << "传入函数的数字: " << num << std::endl;
}

int main()
{
    // 算术运算中的类型提升示例
    int a = 10;
    double b = 3.14;
    // 在加法运算中，int 类型的 a 会自动转换为 double 类型
    double result = a + b; 
    std::cout << "算术运算结果（类型提升）: " << result << std::endl;

    /* ================================================================ */
    // 赋值时的类型转换示例
    double num = 3.14;
    // double 类型的 num 会自动转换为 int 类型，小数部分丢失
    int integerNum = num; 
    std::cout << "赋值转换后的整数: " << integerNum << std::endl;

    /* ================================================================ */
    // 函数调用时的类型转换示例
    short s = 10;
    // short 类型的 s 会自动转换为 int 类型传递给函数
    printNumber(s); 

    return 0;
}

1. 算术运算中的类型提升

在进行算术运算时，如果操作数的类型不同，编译器会将较低类型提升为较高类型，以确保运算的准确性。类型提升的顺序大致为：char/short -> int -> long -> long long -> float -> double。

2. 赋值时的类型转换
   当将一个值赋给不同类型的变量时，编译器会尝试进行隐式类型转换。如果目标类型能够容纳源类型的值，则转换成功；否则可能会导致数据丢失。

3. 函数调用时的类型转换
   在函数调用时，如果实参的类型与形参的类型不匹配，编译器会尝试进行隐式类型转换。

在程序代码3-5中我们清楚的演示了以上三种隐式类型转换的案例，在这个案例中 int 类型的 a 会自动转换为 double 类型。double 类型的 num 会自动转换为 int 类型但会丢失小数部分。short 类型的 s 也会自动转换为 int 类型传递给函数 printNumber。

3.7.2 显式类型转换

C++ 还允许通过强制类型机制显式的进行类型转换，显式类型转换也称为强制类型转换，需要程序员手动指定转换的类型。（C++ 必须有类型规则，而有时候又需要推翻这些死板的规则）。C++ 提供了四种显式类型转换操作符，这将在第15章详细介绍，这里先进行简单说明。

1. static_cast

static_cast 用于基本数据类型之间的转换，以及具有继承关系的类对象指针或引用之间的转换。它在编译时进行类型检查，不进行运行时的类型检查。

2. dynamic_cast

dynamic_cast 主要用于具有继承关系的类对象指针或引用之间的安全向下转换（将基类指针或引用转换为派生类指针或引用）。它在运行时进行类型检查，如果转换不安全则返回空指针（对于指针转换）或抛出 std::bad_cast 异常（对于引用转换）。

3. const_cast
const_cast 用于去除变量的 const 或 volatile 限定符。它只能用于改变对象的常量性或易变性，不能用于改变对象的类型。

4. reinterpret_cast

reinterpret_cast 用于进行最底层的类型转换，它可以将一个指针转换为任意其他类型的指针，也可以将整数类型转换为指针类型。这种转换非常危险，因为它不进行任何类型检查，可能会导致未定义行为。

3.7.3 旧式强制类型转换

1

(type)expression

在 C++ 中，还可以使用类似于 C 语言的旧式强制类型转换，语法为 (type)expression。这种转换方式比较简单，但不够安全，因为它会尝试进行各种可能的类型转换，容易导致意外的结果。

1
2
3
4
5
6
7
8

#include <iostream>
int main()
{
    double num = 3.14;
    int integerNum = (int)num; // 旧式强制类型转换
    std::cout << "Integer number: " << integerNum << std::endl;
    return 0;
}

综上 C++ 中的类型转换提供了多种方式，你可以根据具体的需求选择合适的类型转换方法。在进行类型转换时，要注意避免数据丢失和未定义行为，尽量使用安全的类型转换操作符。

章节阅读提示

在学习 C++ 的过程中，操作符重载是一个具有一定难度的知识点，可能对于当前阶段只学习到“C++ 算数操作符”的你来说有点超纲。为了让你能更顺畅地学习 C++，我们给出以下阅读建议。

现阶段建议
目前先跳过操作符重载这部分内容的学习。因为操作符重载涉及到对类和对象、函数重载等更深入知识的理解，而你当前的知识储备可能还不足以完全掌握它。过早接触可能会让你感到困惑，影响学习的积极性和效果。

后续学习指引
当你完成以下几个关键部分的学习后，就可以返回阅读操作符重载这一小节了：

1. 类和对象
2. 函数重载
3. 构造函数和析构函数

当你完成上述内容的学习后，你将具备足够的知识基础来深入学习操作符重载。此时再返回阅读操作符重载这部分内容，你会发现理解起来更加轻松，也能更好地掌握这一重要的 C++ 特性。

祝坚持到现在的你，在 C++ 的学习之旅中取得进步！

—— Evilrabbit

在 C++ 中，操作符重载允许我们为自定义类型（如类和结构体）重新定义操作符的行为。结合前面提到的除法（整数除法和浮点数除法），我们可以通过操作符重载让自定义类型也支持除法运算。操作符重载是 C++ 的一项特性，它允许程序员为自定义类型重新定义操作符的行为。通过操作符重载，我们可以让自定义类型像内置类型一样使用各种操作符，增强代码的可读性和可维护性。对于除法操作符 /，我们可以为自定义类型定义其除法行为。

3.6.1 整数除法重载示例

假设我们有一个自定义的 Fraction 类表示分数，我们可以重载除法操作符来实现分数之间的除法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include <iostream>

class Fractionz
{
private:
    int numerator, denominator;;   // 定义分子和分母

public:
    // 构造函数
    Fraction(int num = 0, int den = 1) : numerator(num), denominator(den)
    {
        if (den == 0)
        {
            throw std::invalid_argument("Denominator cannot be zero!");
        }
    }

    // 重载除法操作符
    Fraction operator/(const Fraction& other) const
    {
        if (other.numerator == 0)
        {
            throw std::invalid_argument("Division by zero fraction!");
        }
        return Fraction(numerator * other.denominator, denominator * other.numerator);
    }

    // 打印分数
    void print() const
    {
        std::cout << numerator << "/" << denominator << std::endl;
    }
};

int main()
{
    Fraction f1(2, 3);
    Fraction f2(4, 5);

    try
    {
        Fraction result = f1 / f2;
        std::cout << "Result of division: ";
        result.print();
    } catch (const std::invalid_argument& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

在上述代码中：

• Fraction 类有两个私有成员变量 numerator 和 denominator 分别表示分子和分母。
• 构造函数用于初始化分数对象，并检查分母是否为零。
• operator/ 函数是对除法操作符的重载，它接受一个 Fraction 类型的参数 other，并返回一个新的 Fraction 对象，表示两个分数相除的结果。在进行除法时，也会检查除数的分子是否为零。
• print 函数用于打印分数的信息。

3.6.2 浮点数除法重载示例

假设我们有一个自定义的 Complex 类表示复数，我们可以重载除法操作符来实现复数之间的除法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <iostream>

class Complex
{
private:
    double real;
    double imag;

public:
    // 构造函数
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 重载除法操作符
    Complex operator/(const Complex& other) const
    {
        double denominator = other.real * other.real + other.imag * other.imag;
        if (denominator == 0)
        {
            throw std::invalid_argument("Division by zero complex number!");
        }
        double newReal = (real * other.real + imag * other.imag) / denominator;
        double newImag = (imag * other.real - real * other.imag) / denominator;
        return Complex(newReal, newImag);
    }

    // 打印复数
    void print() const
    {
        std::cout << real;
        if (imag >= 0)
        {
            std::cout << " + " << imag << "i" << std::endl;
        }
        else
        {
            std::cout << " - " << -imag << "i" << std::endl;
        }
    }
};

int main()
{
    Complex c1(2.0, 3.0);
    Complex c2(4.0, 5.0);

    try
    {
        Complex result = c1 / c2;
        std::cout << "Result of division: ";
        result.print();
    } catch (const std::invalid_argument& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

在上述代码中：

• Complex 类有两个私有成员变量 real 和 imag 分别表示实部和虚部。
• 构造函数用于初始化复数对象。
• operator/ 函数是对除法操作符的重载，它接受一个 Complex 类型的参数 other，并返回一个新的 Complex 对象，表示两个复数相除的结果。在进行除法时，会计算分母并检查是否为零。
• print 函数用于打印复数的信息。

通过操作符重载，我们可以让自定义类型像内置类型一样方便地进行除法运算，提高代码的可读性和可维护性。

1

int add = 4 + 2;

4 和 2 都是操作数，+ 是加法操作符， 4 + 2 则是一个表达式，其值为 6。下面是 C++ 的 5 种基本算术操作符:

• + 操作符对操作数执行加法运算。例如，4 + 20 等于 24。
• - 操作符从第一个数中减去第二个数。例如，12 - 3 等于 9。
• * 操作符将操作数相乘。例如，28 * 4 等于 112。
• / 操作符用第一个数除以第二个数。例如，1000 / 5 等于 200。如果两个操作数都是整数，则结果为商的整数部分。例如，17 / 3 等于 5，小数部分被丢弃。
• % 操作符求模。也就是说，它生成第一个数除以第二个数后的余数。例如，19 % 6 为 1，因为 19 是 6 的 3 倍余 1。两个操作数必须都是整型，将该操作符用于浮点数将导致编译错误。如果其中一个是负数，则结果的符号依赖于实现^[1]。

当然，变量和常量都可以用作操作数，由于 % 的操作数只能是整数，因此我们将在后面的例子中讨论它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

using namespace std;

int main()
{
    float operands, operated;
    /**
     * 设置为固定点表示法（fixed-point notation）浮点数会以固定的小数位数进行输出，不用科学计数法
     * 如果读者的编译器不接受 ios_base::fixed 也可以使用 ios::fixed
     */
    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << "输入一个数字：";
    cin >> operands;    //操作数
    cout << "输入另一个数字：";
    cin >> operated;    //被操作数

    cout << "operands  = " << operands << "; operated = " << operated << endl;  // 确认输入
    cout << "operands + operated = " << operands + operated << endl;            //加操作
    cout << "operands - operated = " << operands - operated << endl;            //减操作
    cout << "operands * operated = " << operands * operated << endl;            //乘操作
    cout << "operands / operated = " << operands / operated << endl;            //除操作
    return 0;
}

程序的正确输出应该与下列文本相似，从中可以看出 C++ 能够完成简单的算术运算

1
2
3
4
5
6
7

输入一个数字：71.16
输入另一个数字：15.30
operands  = 71.160004; operated = 15.300000
operands + operated = 86.460007
operands - operated = 55.860004
operands * operated = 1088.748047
operands / operated = 4.650980

也许有细心的读者发现了问题！71.16 与 15.30 相加减后结果出现了 .460007 与 .860004。这不是运算问题，而是由于 float 类型表示有效位数的能力有限。C++ 只保证 6 位有效位。如果将 86.460007 四舍五入成 6 位，将得到 86.4600，这是保证精度的正确结果。如果需要更高的精度你可以尝试一下 double 和 long double 的结果。

3.5.1 操作符优先级和结核性

操作符优先级

在数学课上，我们学习过，运算符有其基本的优先级，这即为代数优先级（先乘除、后加减，先括号内、后括号外）。同样在 C++ 中我们也有运算符的优先级，很多表达式都包含有多个操作符。但计算机如何理解并优先使用哪个操作符呢？他们将按照下列介绍逐级参与运算。

1. 作用域解析操作符（::）

这是优先级最高的操作符，用于指定命名空间、类或全局作用域中的标识符。例如：

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
namespace MyNamespace
{
    int value = 42;
}

int main()
{
    std::cout << MyNamespace::value << std::endl;
    return 0;
}

2. 后缀操作符（++、-- 等）

后缀自增和自减操作符会在表达式计算完成后再对变量的值进行改变。例如：

1
2
3
4
5
6
7
8

#include <iostream>
int main()
{
    int num = 5;
    int result = num++;  // 先使用 num 的值 5 赋给 result，然后 num 再自增为 6
    std::cout << "result: " << result << ", num: " << num << std::endl;
    return 0;
}

3. 前缀操作符（++、–、!、~ 等）

前缀自增和自减操作符会先对变量的值进行改变，然后再参与表达式的计算。逻辑非（!）和按位取反（~）操作符也属于这一类。例如：

1
2
3
4
5
6
7
8

#include <iostream>
int main()
{
    int num = 5;
    int result = ++num;  // 先将 num 自增为 6，然后再将 6 赋给 result
    std::cout << "result: " << result << ", num: " << num << std::endl;
    return 0;
}

4. 乘法、除法和取模操作符（*、/、%）

这些操作符用于执行乘、除和取模运算，它们的优先级相同。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 10;
    int b = 3;
    int result = a / b * 2;  // 先进行除法运算 10 / 3 = 3，再进行乘法运算 3 * 2 = 6
    std::cout << "result: " << result << std::endl;
    return 0;
}

5. 加法和减法操作符（+、-）

用于执行加法和减法运算，优先级低于乘法、除法和取模操作符。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 10;
    int b = 3;
    int result = a + b * 2;  // 先进行乘法运算 3 * 2 = 6，再进行加法运算 10 + 6 = 16
    std::cout << "result: " << result << std::endl;
    return 0;
}

6. 关系操作符（<、<=、>、>=）

用于比较两个值的大小关系，返回布尔值。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 10;
    int b = 3;
    bool result = a > b;  // 比较 a 是否大于 b，结果为 true
    std::cout << "result: " << std::boolalpha << result << std::endl;
    return 0;
}

7. 相等性操作符（==、!=）

用于判断两个值是否相等，返回布尔值。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 10;
    int b = 3;
    bool result = a == b;  // 判断 a 是否等于 b，结果为 false
    std::cout << "result: " << std::boolalpha << result << std::endl;
    return 0;
}

8. 逻辑与操作符（&&）

用于逻辑与运算，只有当两个操作数都为真时，结果才为真。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    bool a = true;
    bool b = false;
    bool result = a && b;  // 逻辑与运算，结果为 false
    std::cout << "result: " << std::boolalpha << result << std::endl;
    return 0;
}

9. 逻辑或操作符（||）

用于逻辑或运算，只要两个操作数中有一个为真，结果就为真。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    bool a = true;
    bool b = false;
    bool result = a || b;  // 逻辑或运算，结果为 true
    std::cout << "result: " << std::boolalpha << result << std::endl;
    return 0;
}

10. 条件操作符（?:）

这是 C++ 中唯一的三元操作符，用于根据一个条件表达式的结果选择两个值中的一个。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 10;
    int b = 3;
    int result = (a > b) ? a : b;  // 如果 a 大于 b，则结果为 a，否则为 b
    std::cout << "result: " << result << std::endl;
    return 0;
}

11. 赋值操作符（=、+=、-= 等）

用于将一个值赋给一个变量，优先级较低。例如：

1
2
3
4
5
6
7
8

#include <iostream>
int main()
{
    int a = 10;
    a += 5;  // 等价于 a = a + 5，将 a 的值更新为 15
    std::cout << "a: " << a << std::endl;
    return 0;
}

操作符结合性

当一个表达式中出现多个具有相同优先级的操作符时，操作符的结合性决定了它们的计算顺序。结合性分为左结合和右结合：

1. 左结合

大多数操作符都是左结合的，即从左到右依次计算。例如，加法和减法操作符就是左结合的：

1
2
3
4
5
6
7

#include <iostream>
int main()
{
    int a = 10 - 3 - 2;  // 先计算 10 - 3 = 7，再计算 7 - 2 = 5
    std::cout << "a: " << a << std::endl;
    return 0;
}

2. 右结合

少数操作符是右结合的，如赋值操作符和条件操作符。例如，赋值操作符的右结合性使得连续赋值成为可能：

1
2
3
4
5
6
7
8

#include <iostream>
int main()
{
    int a, b, c;
    a = b = c = 10;  // 先将 10 赋给 c，再将 c 的值赋给 b，最后将 b 的值赋给 a
    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
    return 0;
}

以下是完整的 C++ 操作符优先级和结合性列表，按照优先级从高到低排列，同一组内的操作符优先级相同。

解释说明

• 优先级：数值越小，优先级越高。高优先级的操作符会先于低优先级的操作符进行计算。
• 结合性：
  • 左结合：表达式中相同优先级的操作符从左到右依次计算。
  • 右结合：表达式中相同优先级的操作符从右到左依次计算。

3.5.2 除法分支

在 C++ 里，算术操作符中的除法操作会根据操作数的数据类型呈现出不同的行为，本小节为你详细介绍整数除法和浮点数除法这两个主要分支：

1. 整数除法

当除法操作的两个操作数都是整数类型（像 int、long、short 等）时，C++ 执行的是整数除法。整数除法会直接舍弃商的小数部分，只保留整数部分。

2. 浮点数除法

要是除法操作的操作数中有一个或两个是浮点数类型（例如 float、double），C++ 就会执行浮点数除法，其结果会包含小数部分。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    double a = 7.0;
    double b = 2.0;
    double result = a / b;
    std::cout << "浮点数除法结果: " << result << std::endl;
    return 0;
}

在这个例子中，a 和 b 都是 double 类型。a / b 执行的是浮点数除法，7.0 除以 2.0 的结果是 3.5，因此最终 result 的值为 3.5。

3. 混合类型除法

当一个操作数是整数类型，另一个是浮点数类型时，整数会被隐式转换为浮点数，然后执行浮点数除法。例如：

1
2
3
4
5
6
7
8
9

#include <iostream>
int main()
{
    int a = 7;
    double b = 2.0;
    double result = a / b;
    std::cout << "混合类型除法结果: " << result << std::endl;
    return 0;
}

在这个例子中，a 是 int 类型，b 是 double 类型。在进行除法运算时，a 会被隐式转换为 double 类型，接着执行浮点数除法，所以结果 result 是 3.5。

4. 特殊情况：除数为零

在 C++ 中，无论是整数除法还是浮点数除法，除数都不能为零。如果除数为零，程序会出现未定义行为。对于整数除法，运行时可能会导致程序崩溃；对于浮点数除法，可能会得到 $NaN$（非数）或者 $\pm Inf$（正负无穷大）。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
int main()
{
    int a = 7;
    int b = 0;
    // 以下代码会导致未定义行为，不要这样做
    // int result = a / b;
    // std::cout << result << std::endl;

    double c = 7.0;
    double d = 0.0;
    double result2 = c / d;
    std::cout << "浮点数除以零结果: " << result2 << std::endl;
    return 0;
}

在这个例子中，整数除法 a / b 由于除数为零会引发未定义行为，不建议这样使用。而浮点数除法 c / d 中，7.0 除以 0.0 会得到 inf（正无穷大），输出结果可能会因编译器和系统的不同而有所差异。在实际编程中，要确保除数不为零，避免出现未定义行为。

3.5.3 求模操作符

比起求模操作符来说，多数人更熟悉加、减、乘、除，因此这里花些时间介绍这种操作符。

求模操作符 % 用于返回整数除法的余数。在 C++ 里，当两个整数进行除法运算时，使用 / 操作符会得到商的整数部分（即整数除法），而使用 % 操作符则会得到除法运算后的余数。求模操作符与整数除法相结合，特别适合解决把一个量拆分成不同整数单元的问题。下面以常见的单位转换为例进行说明：

在长度单位体系中，常见的有米、分米、厘米、毫米，其中 1 米 = 10 分米，1 分米 = 10 厘米，1 厘米 = 10 毫米。我们可以将厘米为单位的长度值转换为米和厘米。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>

using namespace std;

int main()
{
    // 定义总厘米长度
    int totalCentimeters = 235;

    // 使用整数除法计算米数
    int meters = totalCentimeters / 100;

    // 使用求模操作符计算剩余的厘米数
    int remainingCentimeters = totalCentimeters % 100;

    // 输出转换结果
    cout << totalCentimeters << " 厘米等于 " << meters << " 米 " << remainingCentimeters << " 厘米" << endl;

    return 0;
}

3.5.4 理论巩固和实践建议

本小结涉及知识点较多且较为相似，为确保自己不会混淆你应该多次重复文中的运算示例，观察其结果和精度问题。当然你也可以简单尝试一下明知是错误的情况，看看编译器会给出什么样子的报错内容，在这种可控环境下的试错可能对你今后的学习有一定的益处。

你也可以对以下代码进行补全和尝试获得运算结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 1. 基本算术运算练习
int a = 15, b = 4;
// 计算并输出：a+b, a-b, a*b, a/b, a%b

// 2. 优先级验证
int result1 = 3 + 4 * 5;     // 验证乘法优先级高于加法
int result2 = (3 + 4) * 5;  // 验证括号改变优先级

// 3. 混合类型运算
int x = 7;
double y = 2.5;
// 尝试各种组合，观察类型转换规则

// 4. 求模应用扩展
// 将秒数转换为小时、分钟、秒格式
int totalSeconds = 3665;
// 使用除法和求模进行转换

建议读者先完成基础练习，确保掌握核心概念后再进行进阶挑战。实践中遇到问题时，可以回看文中的示例代码和解释说明。如确有不理解的地方可以在下方评论区留言，我会一一回复。

在 C++ 源文件开头，常常会使用 #include 编译指令来包含头文件，例如 #include <iostream> 。对于新手程序员来说，这些包含指令就像是有一种 “魔咒的力量”，因为他们需要通过不断地阅读代码示例、实际编写程序来逐渐了解每个头文件能为程序添加哪些功能。只有正确地包含了所需的头文件，程序才能顺利编译和运行。比如，若要正常使用标准输入输出功能，就需要包含 iostream 头文件。

3.4.2 不要把包含文件当作神秘知识

包含文件本质上就是文本文件，它们包含了函数声明、类定义、宏定义等信息。新手程序员不应该把这些头文件看作是神秘难懂、只能依赖使用的东西，而应该有勇气去打开并阅读它们。通过直接阅读头文件的内容，可以更深入地了解其中所提供的功能和接口。例如，当你打开 vector 头文件时，就能看到 std::vector 类的定义以及它所提供的各种成员函数。

3.4.3 找到并查看包含文件的内容

程序中使用 #include 指令包含的所有文件，实际上都存在于计算机的某个位置，或者计算机能够访问到的地方。新手程序员应该学会去找到这些要使用的包含文件，查看它们具体包含了哪些内容。这样做可以让你快速认识到，源文件和头文件是获取知识和信息的优质来源。在很多情况下，它们就是最好的文档。因为头文件中通常会有详细的注释，解释每个函数、类的用途和使用方法。

3.4.4 阅读包含文件习惯的好处

当你开始使用更复杂的包含文件，并且在应用程序中引入其他非标准库时，养成阅读包含文件内容的习惯会非常有帮助。非标准库的文档可能不如标准库那么完善和普及，此时直接阅读头文件就成为了了解库功能和使用方法的重要途径。通过阅读头文件，你可以清楚地知道库提供了哪些功能、每个功能如何使用，从而更高效地在自己的程序中使用这些库。

我们鼓励大家在学习 C++ 的过程中主动去探索和阅读包含文件，将其作为学习和了解 C++ 编程知识的重要资源。

那么为什么会这样？我们究竟被什么洗脑了？我们还能回到从前吗？

在这个信息爆炸的时代，我们仿佛陷入了一个怪圈：越是积极向上的人，越容易在短视频的漩涡中无法自拔。每当我们下定决心专注工作和学习，手指却不听使唤地滑向那一个个充满诱惑的图标。互联网心理学（大家常说的网络心理学）家表明：这不是对象个人的意志力问题，这是一场被我们精心设计过的“注意力抢夺”。

像上文所说的一样，这绝非是你简单的意志力薄弱，而是一场精心策划、基于人类认知弱点的“注意力争夺战”。我们普通人面对的，是无数开发、设计工程师、算法专家以及心理学家精心打造的“多巴胺陷阱”，它精准地把握权衡了大脑寻求即时奖励的机制。越是渴望自我提升、对生活抱有积极期待的人，往往越容易陷入这种“想努力却无力”的漩涡——因为追求“更好”的冲动，恰好被系统巧妙地转化并导流向了那个能提供“即时满足”的虚拟世界。

因此，当我们自责“为什么就是控制不住”时，或许首先需要认清：这场较量并不公平。我们的对手，是旨在最大化占据用户时间的强大算法和产品逻辑。理解这场“战争”的机制，是我们重获专注力、找回自我主导权的第一步。

下面我从社会层面和经济层面简单分析一下当下的情况。

一、从社会层面来看

1.1 社会加速与时间的碎片化

现代生活的一个显著特征是“加速”。我们追求更快的工作节奏、更高效的学习方式以及更即时的信息反馈。这种对“速度”的所谓的崇拜，使得我们的时间被切割成无数碎片。短视频“短、平、快”的特性，恰好与这种碎片化的时间结构完美契合。它成为了填充通勤、排队、工作间隙这些“时间缝隙”的首选工具。本应用于休息或短暂放空的片刻，被短视频迅速占据，我们甚至来不及思考是否有更好的方式可以利用这些时间。

1.2 社会结构变迁与情感需求的转移

社会结构的变化，特别是人际关系的疏离，也为短视频的沉迷提供了土壤。

• 现实连接的弱化：快节奏的生活和高压的工作可能挤压了现实中的深度社交，使得一些人在线上寻求替代性的伪满足。对于独居老人、留守儿童等群体，短视频在某种程度上成为一种填补情感空窗的方式。
• 虚拟社群的构建：短视频平台通过兴趣推荐，快速的帮助用户形成各种亚文化圈层，比如二次元文化圈。这在一定程度上满足了用户的归属感需求。然而，当过度依赖虚拟世界的互动时，可能反而加剧现实生活中的孤独感。

1.3 代际差异

尽管青少年短视频沉迷现象备受关注，但需要认识到，短视频沉迷有向全年龄段扩展的趋势。不同年龄段的用户，其沉迷的动因和表现可能有所不同。例如，中老年人可能因社会角色转变、生活空虚而沉迷，青少年可能出于好奇和 peer pressure（同辈压力），而青壮年则可能用于缓解工作压力。单一地针对某一群体进行防治效果有限，需要社会整体的关注和差异化的引导。

1.4 自我价值重塑

短视频也深刻地改变了文化传播和消费的形态。它赋予了草根创作者更大的发声平台，促进了传统文化（如京剧、非物质文化遗产）的年轻化传播。但另一方面，文化内容在短视频传播中也可能被简化和娱乐化，一些低俗、炫富的内容可能对价值观，尤其是青少年的价值观，产生潜移默化的不良影响。

二、从经济层面来看

现在大部分人提倡的流量就是收益，这句话没有错，我很认可，但如果任何流量都可以转化为收益，那么我只要翻拍刑法的每一条，我一定都可以获得不错的流量和收益。如果人人都这样做、如果短视频中充斥着巨量的原本是用于限制人道德底线的内容，结果会有多可怕？你也不要和我较真说现在监管力度很严格，力度严格也只是“事后买药”。

2.1 流量经济的本质与个体

我们身处一个所谓“流量为王”时代，大家注意，是“所谓”！短视频平台凭借其强大的算法推荐和即时反馈机制，成为流量争夺的主战场。在这里，注意力是稀缺资源，直接与经济利益挂钩，形成“吸睛即吸金”的短期效应。平台通过精准的算法分析用户的兴趣点，不断推送高刺激性的内容，而内容创作者在流量诱惑下，往往优先选择博眼球的策略，例如制造戏剧冲突、煽动情绪或生产低质快消内容。这种机制表面上赋予用户“选择自由”，实则将人困于信息茧房^[1]中。

系统不断强化你的口味、你的偏好，让你看到的全是“想看的”，而非“要看的”。结果，许多原本积极的人发现自己陷入矛盾：明明想专注工作或者学习时，手指却不自觉滑向短视频入口。这不是单纯的意志力薄弱，而是多巴胺奖赏系统被系统性劫持的表现。神经科学研究表明，短视频的高频切换（平均3-5秒一个画面）会持续激活大脑的奖励中枢，抑制前额叶皮层（负责理性控制），长期下来，人对即时反馈的依赖越来越强，而对深度工作的耐心急剧退化。更严重的是，这种机制催化了人性的懒惰，放大了比较心理，使人在虚拟满足中失去独立思辨能力。

如果你还没意识到问题的严重性，请看这张表：

短视频平台基于算法的“个性化推荐”不断强化我们的偏好，将我们困在“信息茧房”中。在我家里时常会出现一种极度影响家庭和谐的情况发生。

我经常因为一句话或一件事（没有录音没有拍照，甚至没有使用手机）收到与之相关联的商品推荐，关联性非常高，比如前一周我的朋友在小区捡到一只英短猫，因为他家本来就有（猫名）金豆了，无法再容纳一只猫在同一个空间“斗争”了，为了避免这只猫继续流浪或被送到救助站，外加这只猫品种也不错，我就接收了。自此之后我每天收到无数次的猫砂、猫粮、猫草等等等等的商品推荐、直播间推荐。点击不感兴趣都没有什么效果。

而我父母成天便是“如何在极短时间搞到几个小目标”、“子女教育一定要恨——所谓棍棒出孝子”、炒股推荐等等等等。

而更年长的一辈爷爷奶奶，每天便是“某某村九旬老人被子女遗弃”、“某某村惊天大案某某弑父弑母”等等等等。

父母让我少买网上的低价劣质产品，而他们搬回家的快递要比山还高，老辈总幻想没有工作能力的自己会被“抛弃”，每次见面都会说手机上谁谁谁简直不是人，爹娘都会抛弃、挨打，而父母听到就成了另外的画风，“怎么？谁要抛弃你们吗？不会给你们吃喝住吗？”每次看似的不起眼争吵时间久了也会成大问题！

大数据分析、算法推荐的本质一定是好的，但经过资本家的调教变成了收割人性的敛财工具。中国优秀的美好的传统文化的推流是少的可怜。阶级斗争和财富平均却让他们说的是头头是道。试问？有多少家庭一顿早餐能消费掉2-3万元？在短视频中好像是绝大多数吧？抱歉，写到这里我参杂了太多个人情感以及不满，但我无能无力改变这个现实，我也无法左右大家的意志。我只想说去其糟粕去其精华是我们该干的事情，如果没有精华那就该放下手机去书店逛逛了。

三、重获专注

吐槽了太多现在该来说说应对之法了。

要摆脱短视频的控制，关键在于理解自律的本质。心理学中的“白熊问题^[2]”告诉我们：越是压制某个念头，它越会挥之不去。因此，与其强行戒断，不如重新规划我们与短视频的关系。

• 设立专注时段，我认为重建深度工作能力的关键。每天安排不受打扰的工作时间，手机打开飞行模式，专注于单一任务。这件事刚开始的时候一定会充满困难，但坚持下来，大脑将重新适应深度思考的状态。其实我坚持写博客也是因为我想戒掉短视频，奈何现在有一部分社交也存在于此，就像没有人能戒掉微信吧。

• 优化视频食谱也很重要。就像注重饮食健康一样，我们需要精心筛选信息源，取消关注低质内容，主动寻找有价值的信息。将被动接受推荐转为主动搜索获取，带着明确目的使用短视频。

• 最狠的操作方法是其实是实施断舍离。连续 7 天将短视频使用时间严格控制在最低限度，用优质信息输入和深度工作替代无目的乱刷。同时，打造一个有利于专注的环境，如使用专注类 App、设置飞行模式、明确划分工作与娱乐空间。

• 最重要的是，培养对生活的控制感。心理学研究发现，拥有高控制感的人往往会感觉自己更年轻、更有活力。当我们能够有效管理自己的时间和注意力时，自然会减少对短视频的依赖。

短视频只是生活的调味品，而非主食。真正积极的人，懂得将宝贵的时间和注意力投入到能够带来持续成长和满足感的活动中。当我们重新掌握注意力的主导权，就能在信息浪潮中保持内心的秩序与工作的效率，成为一个真正的“积极行动者”，而非“积极废人”。

四、最后

信息如此高密度发达的今天请大家永远不忘初心地记住，不论 AI 也好，短视频的推荐算法也罢，它们的产生都是对“人”这个主体对象进行服务的一个特殊实例，我们人类永远是一个具体而又真实的实体，而算法只是服务我们成长的附庸归属，就像汽车永远是载着我们前进的工具，而它不能主导我们想要去往的远方。

祝大家拥有属于自己的，充实且幸福的每一天！

“浮点型” 这个名称来源于它在计算机内部存储数据的方式。在这种表示方法中，一个浮点数由两部分组成：尾数（也称为有效数字）和指数。尾数是一个固定精度的数字，指数则用于表示小数点的位置，通过改变指数的值，可以让小数点 “浮动”，所以称为 “浮点型”。例如：对于科学计数法表示的数字 $2.34 \times 10^4$，其中 $2.34$ 是尾数，$4$ 是指数。在计算机中存储的浮点数类似这种形式，但计算机采用二进制编码。

我们之所以要学习使用浮点型，是因为整形无法或者说很难有效地表示一些“超常”的数值范围。例如，我们无法用整形表示太阳到地球的距离（约等于 $1.496 \times 10^{11}$ 米），或是一些极小的数值。且在诸多领域中很多时候我们都需要用到带有小数部分的数值。

浮点数在计算机中的表示方法与整数有天壤之别，幸运的是我们不必再去过多探究内部实现的细节。我们只需掌握如何使用浮点类型即可。

3.3.1 浮点数表示方法

C++ 有两种浮点数表示方式。

1. 第一种是常用的小数点表示法

1
2
3
4
5

1.0
1.23
12.34
0.0001
27199.10102

当我们使用浮点类型来保存值时，小数点后即使是 0 小数点也将确保该数字以浮点格式表示即 1.0 而不是 1。

2. 第二种是科学计数表示法

1
2
3
4
5
6

1.23E5
-15.3E9
8.33E5
-8.11e-10
9.54E-8
4.02E+7

在科学计数法中，“E”（或 “e”）表示乘以 10 的幂次方。

对于 “1.23E5”，其中 “E5” 表示 10 的 5 次方，即 100000，那么就是 $1.23 \times 10^5$ 或 $1.23 \times 100000$ 了。

3.3.2 浮点数的类型

在 C++ 中同样也有 float、double 和 long double 三种浮点类型。这些类型数按照它们可以表示的有效数字和允许的指数最小范围来描述的。例如：对于数字 0.0034，它的有效数位是两位（3 和 4），前面的零是用于确定小数点位置的，不是有效数字；而 3.40 这个数字的有效数位是三位（3、4 和最后的 0），最后的 0 表示这个数字精确到了百分位。

对于浮点型数据，有效数位是衡量其精度的重要指标。如单精度浮点数（float）大约有 6-7 位有效数字，双精度浮点数（double）大约有 15-16 位有效数字。例如:一个 float 类型的数值表示为 3.141592（实际上由于 float 精度限制，这可能已经存在舍入误差），其有效数位约为 6 位；而对于一个 double 类型表示为 3.141592653589793，有效数位约为 15 位。

事实上，C 和 C++ 对于有效位数的要求是 float 至少 32 位，double 至少 48 位，且不少于 float，而 long double 至少要和 double 一样多。这三种数据类型的有效位数可以一样多，不过通常，float为 32 位，double 为 64 位，long double 为 80、96 或 128 位。而它们的指数范围则至少是 -37～37。

3.3.3 浮点常量

在程序中书写浮点常量的时候，程序将把它存储为哪种浮点类型呢？在默认情况下，像 8.24 和 2.4E8 这样的浮点常量都属于 double 类型。如果希望常量为 foat 类型，请使用 f 或 F 后缀。对于 long double 类型，可使用 l 或 L 后缀(由于 l 看起来像数字 1，因此 L 是更好的选择)。

下面是一些范例:

1
2
3
4

1.234f      // 浮点常量
2.34E20F    // 浮点常量
2.345324E28 // 双精度浮点常量
2.2L        // 长双精度浮点常量

3.3.4 浮点数的优缺点

浮点数是一种用于表示实数的数值类型，在计算机编程和科学计算中被广泛使用。它有自身独特的优势，但也存在一些缺点。

优点

1. 能表示大范围的数值

浮点数可以表示非常大或非常小的数值。例如，在科学计算中，常常会遇到极大或极小的数值，像宇宙中天体的质量（非常大）、微观粒子的尺寸（非常小）等。以常见的双精度浮点数（double）为例，它能表示的数值范围大约是 $\pm1.7\times10^{-300}$ 到 $\pm1.7\times10^{308}$ ，这使得它能够处理各种极端情况下的数值计算。

2. 适合近似计算

在很多实际应用场景中，并不需要精确表示所有数值，只需要一个近似值即可。浮点数可以在一定精度范围内提供对实数的近似表示，满足大多数实际问题的需求。比如在物理模拟、金融计算中的利率计算、图形图像处理中的颜色值表示等领域，使用浮点数进行近似计算可以在保证一定精度的前提下，提高计算效率。

3. 支持小数运算

浮点数能够直接表示和处理小数，这在许多实际应用中是必不可少的。例如，在商业计算中涉及到货币金额的计算，或者在工程领域中对物理量（如长度、重量、速度等）的测量和计算，都需要处理小数部分。使用浮点数可以方便地进行这些小数运算，而无需额外的转换和处理。

缺点

1. 存在精度损失

浮点数在计算机中是以二进制形式存储的，而二进制无法精确表示所有的十进制小数。这就导致在进行浮点数运算时，可能会出现精度损失的问题。例如，对于十进制小数 0.1，它无法用二进制浮点数精确表示，在计算机中存储和计算时会存在一定的误差。这种精度损失在多次运算累积后可能会变得比较明显，影响计算结果的准确性。

2. 运算速度相对较慢

相比于整数运算，浮点数运算通常需要更多的硬件资源和时间。这是因为浮点数的表示和运算规则更为复杂，需要专门的浮点运算单元（FPU）来处理。在一些对性能要求极高的应用场景中，浮点数运算的速度可能会成为瓶颈。例如，在实时游戏开发、高性能计算等领域，大量的浮点数运算可能会导致程序运行缓慢。