Posts on 鹿鸣青野的blog

AI 时代 Qt 开发新路线(ACP + 专家模式)

Tue, 13 Oct 2026 00:00:00 +0000

适用人群:有 Qt/C++ 基础,想了解 2026 年 AI 如何重塑 Qt 开发工作流的人。更新日期:2026-08-21

1. 时代背景:IDE 接入 ACP

核心要点:AI 不再是一个网页对话框,而是被「缝」进开发工具——Qt Creator 20 原生支持四种 AI 连接方式,其中 ACP Client 让 AI 代理能直接改代码、跑命令、触发构建。

ACP(Agent Client Protocol) 是客户端软件与 AI 编程代理之间的开放协议(Zed 团队维护),让 IDE 原生出现「侧栏 agent」——类似 VS Code Copilot 侧栏的效果。
已确认(2026-08-21,官方文档):Qt Creator 20 的「Using AI」一节列出四种 AI 扩展:

扩展	作用
ACP Client	用 ACP 连接理解你代码库的 AI 代理,替你改文件、跑命令、触发构建(需配合 MCP Server 扩展启用动作)
GitHub Copilot	接入 Copilot,编辑模式内补全建议
MCP Server	让 AI 助手经 MCP 控制 Qt Creator(调试 / 构建 / 工程管理)
Qt AI Assistant	Qt 自带编程助手,接 LLM 后自动补全、建议修复、写测试与文档

官方链接:https://doc.qt.io/qtcreator/creator-using-ai.html(20.0 快照:https://doc-snapshots.qt.io/qtcreator-20.0/creator-using-ai.html)
意义:AI 从「聊天窗口」升级为「开发环境里的协作者」;而要让这个协作者说对 Qt,就得解决它记不住 / 会乱编 API 的问题 —— 这就是下一节。

2. qt专家模式:降低 LLM 幻觉的核心手段

核心要点:不让 AI 背文档,而是让它「先抓官方文档回来,再基于抓到的文本作答」——这就是 Agentic RAG。

atomic 原子操作

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 std::atomic 在 Go 里是 sync/atomic 包：无锁计数器、无锁标志位、无锁状态机的最优解

一、简述

sync/atomic 提供对内存地址的原子操作：Add（原子加）、Load（原子读）、Store（原子写）、CompareAndSwap（比较并交换）、Swap（交换）。它们作用于 int32 / int64 / uint32 / uint64 / uintptr / unsafe.Pointer 以及 atomic.Value。

和 Mutex 相比，原子操作是免锁（lock-free）的：既不阻塞、也无上下文切换开销，在「高频计数器、状态标志、一次性初始化标志」这类场景下性能明显优于锁。代价是只能保护单变量，且不能声明「一段代码的整齐」。

核心要点：读——Load、写——Store、改——Add / CompareAndSwap。把「多步的读-改-写」用一个 CAS 原子完成，是理解 Go 原子操作的钥匙。C++ 里的 std::atomic<int> 心智模型几乎原样平移，差异只在 API 命名和哪些类型支持。

二、C++ 对照速查表

概念	C++	Go	关键差异
原子整数	`std::atomic<int> n{0}`	`var n atomic.Int64`（或 `var n int64` + `atomic.AddInt64`）	Go 1.19+ 有类型化 `atomic.Int64`，更顺手
原子加	`n.fetch_add(1)`	`atomic.AddInt64(&n, 1)`	Go 返回新值；`AddInt32` / `AddUint64` 等按类型
原子读	`n.load()`	`atomic.LoadInt64(&n)`	Go 读不写也有可能被优化异常，必须用 Load
原子写	`n.store(42)`	`atomic.StoreInt64(&n, 42)`	Go 生硬但显式；`Load`/`Store` 配对使用
比较并交换	`n.compare_exchange_strong(expected, desired)`	`atomic.CompareAndSwapInt64(&n, old, new)`	CAS 失败返回 false，循环重试是惯用法
原子交换	`n.exchange(42)`	`atomic.SwapInt64(&n, 42)`	有返回：交换前旧值
原子布尔/指针	`std::atomic<bool>` / `std::atomic<T*>`	`atomic.Bool`（1.19+）/ `atomic.Pointer[T]`（1.19+）	Go 类型化版本避免手写 unsafe.Pointer
任意值原子存取	`std::mutex` 包 struct	`atomic.Value`（存储任意类型）	Value 的 Load 要求「上次存过的类型」
内存顺序	`memory_order_relaxed` / `seq_cst`	Go 不暴露 memory_order，原子操作只有一种语义	自 Go 1.19 起内存模型正式规定：原子访问之间顺序一致（sequentially consistent）

三、逐主题详解

3.1 计数器：`AddInt64` / `AddUint64`

经典场景——无锁计数器，多 goroutine 并发累加。

Boost.Asio 回调机制初步窥探

Tue, 13 Oct 2026 00:00:00 +0000

验证 Boost.Asio 开发环境 + 理解异步回调与 Qt 信号槽的对应关系

一、环境验证：异步定时器

Asio 是纯头文件库（Header-Only），不需要 b2.exe 编译，配置包含目录后即可 #include 使用。

验证代码：

#include <iostream>
#include <boost/asio.hpp>

int main() {
 boost::asio::io_context io;

 boost::asio::steady_timer timer(io, std::chrono::seconds(3));

 timer.async_wait([](const boost::system::error_code& ec) {
 if (!ec) {
 std::cout << ">>> 3s elapsed, async callback fired" << std::endl;
 }
 });

 std::cout << "--- main thread continues immediately ---" << std::endl;

 io.run();
 return 0;
}

预期输出（顺序证明异步非阻塞）：

--- main thread continues immediately ---
（3 秒间隔）
>>> 3s elapsed, async callback fired

证明了三件事：

C/C++ 内存布局、程序构建与静态库动态库

Tue, 13 Oct 2026 00:00:00 +0000

从内存区域划分（.text / .rodata / .data / .bss / 栈 / 堆）讲到构建四阶段（预处理 → 编译 → 汇编 → 链接），再到静态库与动态库的创建、链接行为差异，末尾汇总易错点。

一、内存布局在构建阶段就确定

Determined at Build Time：.text / .rodata / .data / .bss 的内存布局、大小在编译链接构建阶段就确定，不是程序跑起来才决定。这几段都属于 static lifetime 静态生命周期，由编译器自动管理分配与释放，程序员不能手动干预申请释放。

按数据类型、生命周期和作用域，C/C++ 程序的内存通常划分为五大区域：代码区、全局/静态存储区、栈区、堆区、常量区。其中代码区对应 .text，常量区对应 .rodata，全局/静态存储区对应 .data 与 .bss，栈区与堆区则在运行时分配。

1. `.text` 代码段（文本段 / 代码区）

存储内容：编译之后的机器指令（machine code），即写出的函数、if/for 循环、main 函数等翻译成 CPU 能执行的指令。所有的函数定义、控制结构都会被转换成机器指令存放在这里。
大小：Fixed size，构建阶段确定大小。
权限：Read-only 只读，防止运行时篡改程序指令。这部分内存是共享的，在程序执行期间不会改变。
生命周期：静态生命周期，进程整个运行期间都存在，进程退出由操作系统回收。
管理：完全由编译器、链接器自动管理，程序员没有 API 手动分配释放本段内存。

编译时，main、func 等函数的代码被转换成机器指令存放在可执行文件的代码段中（此时还在磁盘上的可执行文件里）；程序运行时，操作系统把这些指令加载到内存的代码段，CPU 再从内存的代码段中读取并执行。

2. `.rodata` 只读数据段（常量区）

存储内容：初始化后的常量，比如字符串字面量 "hello world"、const char *p = "abc" 这类常量字符串，以及全局 const 常量。
权限：只读 Read-only，程序运行不能修改，写操作会触发段错误。这部分内存同样通常在程序执行期间不会改变。

区分：const int a = 10; 声明在全局放 rodata；局部 const 变量本质还是在栈上。

C++ namespace、const 与 constexpr 知识点总结

Tue, 13 Oct 2026 00:00:00 +0000

命名空间、常量限定符与编译期常量三件套：语法、特点表、易混点（const 修饰指针的读法）、C++11/14/17/20 的演进，以及综合实战示例。

1. namespace 命名空间

namespace（命名空间）用于避免全局命名冲突，把相关的类型、函数、变量组织在一起，形成逻辑上的"作用域边界"。

核心要点：命名空间本质上是给标识符加了一个"姓氏"，从而把不同的名字区分开。

1.1 基本声明与使用

#include <iostream>

namespace Math {
 const double PI = 3.141592653589793;

 int add(int a, int b) {
 return a + b;
 }
}

int main() {
 // 使用 "::" 作用域限定符访问命名空间中的成员
 std::cout << Math::PI << std::endl; // 3.14159...
 std::cout << Math::add(3, 4) << std::endl; // 7
 return 0;
}

1.2 命名空间的特点

特点	说明
可嵌套	命名空间内部可以再定义命名空间
可累加	同一作用域下多次声明同一命名空间会合并
可匿名	匿名命名空间相当于"文件内 static"，仅本文件可见
可起别名	`namespace M = Math;` 简化访问

1.3 嵌套命名空间

namespace Outer {
 namespace Inner {
 void foo() { /* ... */ }
 }
}

// C++17 起可以简写为：
namespace Outer::Inner {
 void bar() { /* ... */ }
}

// 访问方式
Outer::Inner::foo();
Outer::Inner::bar();

1.4 匿名命名空间

匿名命名空间中的成员只在当前翻译单元（.cpp 文件）内可见，等价于 static 全局变量/函数，用于隔离实现细节。

C++ 并发编程：互斥锁、条件变量与原子操作

Tue, 13 Oct 2026 00:00:00 +0000

线程创建与 join/detach 之外的另一半问题：共享数据怎么同步。覆盖数据竞争、互斥锁的三种用法、条件变量生产者-消费者、原子操作与死锁。

核心概念速查

概念	说明	关键点
互斥锁	同一时刻只允许一个线程进入	`std::mutex`
lock_guard	RAII 自动加解锁	推荐,防遗漏
unique_lock	更灵活的 RAII 锁	可手动解锁、可条件变量
条件变量	线程间的等待/通知	`std::condition_variable`
原子操作	无锁的线程安全	`std::atomic`
数据竞争	多线程同时访问共享数据	未定义行为,必须防

为什么需要锁

// 无锁: 两个线程同时对 counter++ 可能丢失更新
// counter++ 实际是"读-改-写"三步,可能交错
int counter = 0;

void add() {
 for (int i = 0; i < 100000; ++i)
 ++counter; // 数据竞争!
}

互斥锁三种用法

#include <mutex>

std::mutex g_mutex;

// 方式1: 原始 lock/unlock(容易忘解锁,不推荐)
void f1() {
 g_mutex.lock();
 // ... 临界区
 g_mutex.unlock(); // 忘写或中间 return 就死锁
}

// 方式2: lock_guard (推荐,作用域结束自动解锁)
void f2() {
 std::lock_guard<std::mutex> guard(g_mutex);
 // ... 临界区
} // 这里自动 unlock

// 方式3: unique_lock (需要手动解锁/延迟加锁时)
void f3() {
 std::unique_lock<std::mutex> lock(g_mutex);
 // ... 临界区
 lock.unlock();
 // ... 不需要锁的部分
}

条件变量：生产者-消费者

#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex mtx;
std::condition_variable cv;
std::queue<int> q;

// 生产者
void producer() {
 for (int i = 0; i < 10; ++i) {
 std::lock_guard<std::mutex> lock(mtx);
 q.push(i);
 cv.notify_one(); // 通知一个等待的消费者
 }
}

// 消费者
void consumer() {
 while (true) {
 std::unique_lock<std::mutex> lock(mtx);
 // wait 会: 释放锁等待 → 被唤醒 → 重新加锁
 cv.wait(lock, []{ return !q.empty(); });
 int val = q.front();
 q.pop();
 lock.unlock();
 // 处理 val...
 }
}

原子操作

#include <atomic>

std::atomic<int> counter{0};
// counter++ 是原子操作,无需加锁
// 适用场景: 计数器、标志位、自旋

// 对比:
// 普通 int ++ → 需 mutex
// atomic ++ → 无锁,更快

死锁

死锁四个必要条件:
1. 互斥 资源只能一个线程占用
2. 持有并等待 拿着一个锁还想要另一个
3. 不可剥夺 别人不能抢走已持有的锁
4. 循环等待 两个线程彼此持有对方要的锁

例子:
线程A持锁1等锁2 + 线程B持锁2等锁1 → 死锁

避免: 全局加锁顺序一致 / 用 std::lock 一次锁多个

常见坑

问题	原因	解决
死锁	加锁顺序不一 / 忘解锁	固定顺序 / `std::lock` / RAII
假唤醒	条件变量被无故唤醒	`wait` 用谓词条件,循环检查
性能差	锁粒度太粗	缩小临界区 / 用原子
数据竞争	忘记加锁	一律 RAII 锁,变量尽量用 atomic
忙等耗 CPU	自旋锁滥用	用条件变量阻塞等待

顿悟

锁保护的是「数据」，不是「代码」：所有访问同一个共享变量的地方都要用同一把锁，漏一处就出 bug。
RAII 是防呆设计：lock_guard 把"忘解锁"从可能性变成不可能，这是 C++ 现代写法核心。
原子 ≠ 万能：只能处理单个变量的简单操作；涉及多个变量的一致性仍需锁。
条件变量的 wait 里一定有循环：防止假唤醒，这是教科书写法，别省。

自测清单

理解数据竞争为什么会丢更新
会用 std::mutex + std::lock_guard
区分 lock_guard 与 unique_lock 的适用场景
能写生产者-消费者（条件变量）
理解死锁四条件，知道如何避免
知道什么时候用 std::atomic

C++ 函数指针、std::function 与 lambda

Tue, 13 Oct 2026 00:00:00 +0000

“把函数当值用"的三种写法：函数指针、std::function、lambda。包含语法拆解、三者对比、捕获方式速记与常见坑。

核心概念速查

概念	说明	关键点
函数指针	存函数地址的变量	C 风格,语法绕
std::function	通用函数包装器	C++11,可存 lambda/仿函数
lambda	匿名函数对象	C++11,现代首选
回调	函数指针的典型用途	事件、排序、遍历
捕获	lambda 使用外部变量	`[ ]` `[&]` `[=]` `[x]`

为什么需要函数指针

把"行为"作为参数传递，让代码更灵活。

// 没有函数指针: 每有一种排序规则就要写一个函数
void sort_ascending(int* arr, int n);
void sort_descending(int* arr, int n);

// 有函数指针: 一个排序函数,规则由调用方决定
void sort(int* arr, int n, bool (*compare)(int, int));

函数指针基础语法

#include <iostream>

// 定义两个比较函数
bool ascending(int a, int b) { return a < b; }
bool descending(int a, int b) { return a > b; }

// 参数是函数指针: bool (*compare)(int, int)
void sort(int* arr, int n, bool (*compare)(int, int)) {
 for (int i = 0; i < n - 1; ++i)
 for (int j = i + 1; j < n; ++j)
 if (compare(arr[j], arr[i])) // 调用比较函数
 std::swap(arr[i], arr[j]);
}

int main() {
 int arr[] = {3, 1, 4, 1, 5};
 sort(arr, 5, ascending); // 传函数名(自动转成指针)
 // sort(arr, 5, &ascending); // 显式取地址也可以

 sort(arr, 5, descending);
 for (int x : arr) std::cout << x << " ";
 return 0;
}

语法记忆：bool (*compare)(int, int) —— *compare 是函数名，(int,int) 是参数，bool 是返回类型。不加括号 bool *compare(...) 就变成返回指针的函数了。

C++ 基础遗漏知识点：bool、sizeof、auto、nullptr 与 static

Tue, 13 Oct 2026 00:00:00 +0000

容易被忽略但常出问题的基础语法点：bool 与 boolalpha、sizeof 的指针陷阱、auto 的 const 剥离、nullptr 与 static。

1. bool 类型与 boolalpha

核心规则

场景	结果	说明
`bool b = true`	输出 `1`	默认输出数字
`bool b = false`	输出 `0`	默认输出数字
`bool b = -8`	输出 `1`	非零即为 true
`bool b = 0`	输出 `0`	零即为 false

boolalpha 操纵符

使用 std::boolalpha 可以让 cout 输出 true/false 而不是 1/0。

#include <iostream>
using namespace std;

int main() {
 bool isTrue = true;

 // 默认输出（数字）
 cout << "默认: " << isTrue << endl; // 输出: 1

 // 使用 boolalpha（文字）
 cout << boolalpha;
 cout << "boolalpha: " << isTrue << endl; // 输出: true

 // 非零值也为 true
 bool b = -8;
 cout << "-8 转 bool: " << b << endl; // 输出: true

 return 0;
}

常见陷阱

// 陷阱1：非零即为 true
bool b1 = 42; // true
bool b2 = -1; // true
bool b3 = 0.001; // true
bool b4 = nullptr; // false (C++11)

// 陷阱2：bool 与整数混合运算
int a = true + true; // a = 2（true 被提升为 1）
int b = true * 10; // b = 10

2. sizeof 运算符

基本用法

#include <iostream>
using namespace std;

int main() {
 cout << "char: " << sizeof(char) << endl; // 1
 cout << "short: " << sizeof(short) << endl; // 2
 cout << "int: " << sizeof(int) << endl; // 4
 cout << "long: " << sizeof(long) << endl; // 4 或 8
 cout << "long long: " << sizeof(long long) << endl; // 8
 cout << "float: " << sizeof(float) << endl; // 4
 cout << "double: " << sizeof(double) << endl; // 8

 // 数组
 int arr[10];
 cout << "int[10]: " << sizeof(arr) << endl; // 40

 // 指针
 int* p;
 cout << "int*: " << sizeof(p) << endl; // 4 或 8

 return 0;
}

动态数组的 sizeof 陷阱

int* arr = new int[10];
cout << sizeof(arr) << endl; // 输出 4 或 8（指针大小，不是数组大小！）

// 正确获取动态数组大小：需要额外传参或用 vector

3. auto 关键字（C++11）

基本用法

auto x = 42; // int
auto y = 3.14; // double
auto z = "hello"; // const char*
auto flag = true; // bool

// 推荐用于复杂类型
#include <vector>
#include <map>

std::vector<int> v = {1, 2, 3};
auto it = v.begin(); // std::vector<int>::iterator

std::map<std::string, int> m;
auto pair = std::make_pair("key", 1);

注意事项

// auto 会忽略顶层 const
const int a = 10;
auto b = a; // b 是 int，不是 const int
const auto c = a; // c 是 const int

// 引用形式的 auto 才保留底层 const
const int& ref = a;
auto ref2 = ref; // ref2 是 int 拷贝——普通 auto 剥离引用,连同底层 const 一起丢
auto& ref3 = ref; // ref3 是 const int&——auto& 保留底层 const(不能改 *ref3)

4. nullptr（C++11）

与 NULL 的区别

// NULL 在 C++ 中可能是 0 或 (void*)0
void func(int);
void func(char*);

func(NULL); // 编译错误！歧义
func(nullptr); // OK，调用 func(char*)

最佳实践

// 初始化指针
int* p = nullptr;

// 判断指针
if (p != nullptr) {
 // 使用 p
}

// 函数参数
void foo(int* ptr) {
 if (ptr == nullptr) {
 return;
 }
}

5. const 与 constexpr（简记）

特性	const	constexpr
初始化时机	运行时	编译时
可用于函数返回值	是	是
编译期常量	否	是

const int x = 10; // OK
constexpr int y = 20; // OK，编译期常量

// constexpr 函数
constexpr int square(int n) {
 return n * n;
}
constexpr int val = square(5); // 编译期计算

const 与 constexpr 的完整对比、constexpr 函数、if constexpr、C++20 的 consteval/constinit，见另一篇《C++ namespace、const 与 constexpr 知识点总结》。

C++ 网络编程基础：Socket API 与 TCP 通信

Tue, 13 Oct 2026 00:00:00 +0000

围绕 Socket API 与 TCP/UDP 通信的核心概念、函数对照、示例代码与常见坑。

核心概念速查

概念	说明	关键点
Socket	网络通信端点	文件描述符抽象
TCP	面向连接、可靠	三次握手、四次挥手
UDP	无连接、不可靠	快速、轻量
sockaddr	通用地址结构	IPv4/IPv6 统一接口
字节序	大端/小端转换	`htons()` `htonl()`

TCP 三次握手与四次挥手

三次握手(建立连接):
 Client ──SYN────▶ Server
 Client ◀─SYN+Ack─ Server
 Client ──Ack────▶ Server

四次挥手(关闭连接):
 Client ──FIN────▶ Server
 Client ◀─Ack───── Server
 Client ◀─FIN───── Server
 Client ──Ack────▶ Server

TCP 客户端-服务器模型

服务器: socket() → bind() → listen() → accept() → recv/send → close()
客户端: socket() → connect() → send/recv → close()

核心函数对照表

函数	用途	参数要点
`socket()`	创建套接字	`AF_INET, SOCK_STREAM, 0`
`bind()`	绑定地址	套接字 + sockaddr_in
`listen()`	监听连接	backlog 队列长度
`accept()`	接受连接	返回新套接字描述符
`connect()`	发起连接	服务器地址
`send/recv()`	发送/接收数据	缓冲区 + 长度
`htons/htonl()`	主机→网络字节序	short/long
`ntohs/ntohl()`	网络→主机字节序	short/long

从 Qt 到原生 Socket

Qt 写法	原生等价物	差异要点
`server.listen(QHostAddress::Any, 8080)`	`socket()` + `bind()` + `listen()` 三步	Qt 一行帮你做三件事
`newConnection` 信号 → `nextPendingConnection()`	`accept()`	Qt 信号通知;原生阻塞死等
`socket->connectToHost("ip", port)`	`inet_pton()` + `connect()`	IP 解析要自己做
`socket->write(bytes)`	`send(fd, buf, len, 0)`	返回值要检查,可能只发一半
`readyRead` 信号 → `readAll()`	`recv(fd, buf, size, 0)`	没有"就绪通知",直接阻塞读
`errorOccurred` / `stateChanged`	检查返回值 + `errno`	错误要手动判断
`QUdpSocket::writeDatagram/readDatagram`	`sendto()/recvfrom()`	多一个对端地址参数
`QHostAddress("127.0.0.1")`	`sockaddr_in` + `inet_pton()`	字符串 IP 手动转结构体
端口字节序自动处理	必须自己 `htons()`	Qt 内部帮你转了

核心差异：Qt 信号槽背后是「事件循环 + 就绪通知」(reactor 模式)。原生编程没有这个循环——要么阻塞死等，要么用线程，要么用 select/epoll 自己搭事件循环。学原生网络的本质，就是把 Qt 隐藏的三件事（fd 管理、字节序、事件分发）亲手做一遍。

C++ 线程基础：std::thread、join/detach 与传参陷阱

Tue, 13 Oct 2026 00:00:00 +0000

std::thread 的创建方式、join 与 detach 的语义、传参陷阱与常见坑。同步机制（互斥锁、条件变量、原子操作）见另一篇并发笔记。

核心概念速查

概念	说明	关键点
进程	独立运行的程序实例	有独立内存空间
线程	进程内的执行单元	共享进程内存
std::thread	C++11 线程库	`#include <thread>`
join	等待线程结束	阻塞当前线程
detach	分离线程	后台运行,不再可 join

进程 vs 线程

维度	进程	线程
内存空间	独立	共享
通信	管道/队列/文件	直接共享变量(需同步)
切换开销	大	小
创建开销	大	小
崩溃影响	只影响自身	可能带崩整个进程
适用场景	隔离、分布式	高并发、I/O 密集

创建线程

#include <iostream>
#include <thread>

void hello() {
 std::cout << "Hello from thread\n";
}

int main() {
 // 方式1: 无参函数
 std::thread t1(hello);

 // 方式2: lambda
 std::thread t2([]{
 std::cout << "Hello from lambda\n";
 });

 // 方式3: 带参函数
 auto print_num = [](int n) {
 std::cout << "Number: " << n << "\n";
 };
 std::thread t3(print_num, 42);

 t1.join();
 t2.join();
 t3.join();
 return 0;
}

join 与 detach

操作	行为	何时用
`join()`	等待线程结束才继续	需要线程结果时
`detach()`	立即返回,线程后台跑	结果不关心时(慎用)

陷阱：线程要么 join 要么 detach，都不做 → 析构时 std::terminate() 崩溃。detach 的线程访问已销毁的对象 → 未定义行为。

C++ 项目约定：目录结构、依赖管理、构建与 Git

Tue, 13 Oct 2026 00:00:00 +0000

所谓「约定」= 一套项目结构规范 + 依赖管理规范：以后不管做什么项目，都按这个套路来，不用每次重新想。

适用背景：Windows（VS2022）只做 Boost + OpenCV，不做 Qt；Qt 开发放在 Linux（Ubuntu 虚拟机/服务器）。

文中 <OpenCV安装目录>、<Boost根目录>、<项目根目录> 为占位符，替换成本机实际目录即可。

一、总体原则

三句话：

CMake 是唯一的构建系统，不碰 qmake、不碰手动 .vcxproj。
依赖一律走环境变量 + find_package，不在 CMakeLists.txt 里硬编码路径。
Windows 端 IDE 是 VS2022 + CMake 项目模式；Linux 端用 Qt Creator 或 VS Code。

二、目录结构约定（Windows 端）

每个项目固定长这样：

<项目根目录>\<项目名>\
├── CMakeLists.txt
├── CMakePresets.json
├── CMakeUserPresets.json # 本地预设（不提交 Git）
├── .gitignore
├── README.md
├── src\ # 源码
│ ├── main.cpp
│ ├── core\ # Boost 业务逻辑
│ │ ├── Service.h
│ │ └── Service.cpp
│ └── vision\ # OpenCV 图像处理
│ ├── ImageProcessor.h
│ └── ImageProcessor.cpp
├── include\ # 对外头文件（可选）
├── resources\ # 静态资源、图片（可选）
├── tests\ # 测试代码（可选）
├── third_party\ # 第三方源码（可选，一般不用）
└── out\ # 构建输出（不提交 Git）
 └── build\
 ├── debug\
 └── release\

关键点：

channel 详解

Tue, 13 Oct 2026 00:00:00 +0000

C++ 里你得自己造「互斥锁 + 条件变量 + 队列」才能做到的线程通信，Go 用一个 channel 就把它变成了语言级原语

一、简述

channel（通道）是 Go 并发模型的核心，它的口号是：

「Do not communicate by sharing memory; instead, share memory by communicating.」 —— 不要通过共享内存来通信，而要通过通信来共享内存。

一个 channel 就是一个带类型的 FIFO 队列，goroutine 之间通过它发送 / 接收数据，同时天然完成了同步（谁等谁、什么时候等）与数据传递两件事。

作为 C++ 开发者，你过去写线程同步大概是这样：std::mutex 保护共享数据 + std::condition_variable 通知 + std::queue 存数据 + 各种 unique_lock。而 Go 把这三件套打包成了一个 channel：发送阻塞、接收阻塞、容量限制、关闭通知全部内建，而且它在语言层面保证了 channel 操作本身的线程安全。

本笔记覆盖：创建、无缓冲 / 有缓冲的阻塞语义、单向 channel、关闭与 range 消费、nil channel、死锁场景，以及「channel 当锁」的奇技淫巧。

二、C++ 对照速查表

概念	C++	Go	关键差异
消息队列	`std::queue<T>` + `std::mutex` + `std::condition_variable`	`ch := make(chan T)`	Go 一条语句搞定，且是语言级原语
无缓冲阻塞队列	手写「空/满都等条件变量」的队列	`make(chan T)`（默认无缓冲）	无缓冲 channel 天然同步：发=等收
有缓冲队列	`std::queue` + 信号量限制	`make(chan T, 5)`	缓冲即容量，满则发送阻塞
发送操作	`queue.push(x); cv.notify_one();`	`ch <- x`	`<-` 方向右：发送
接收操作	`queue.pop();`（空时等 cv）	`x := <-ch`	`<-` 方向左：接收
队列空时接收	条件变量等待 + 谓词循环	阻塞直到有值	Go 不需要手写谓词循环
队列满时发送	信号量 / 容量检查	阻塞直到有空位	缓冲满才阻塞，缓冲空才阻塞
生命周期管理	队列对象手动析构、小心悬垂	`close(ch)`，只能发送方关闭	关闭后 range 自动结束
多读多写	一把锁 + 一个队列满危险	内建线程安全，任意并发收发	Go 收发都允许并发，无需额外锁
非阻塞操作	try_lock / 检查队列非空	`select + default`（下篇讲）	select 是非阻塞收发的标准姿势

三、逐主题详解

3.1 创建 channel：`make`

package main

import "fmt"

func main() {
 // 无缓冲 channel：接收方和发送方必须同时准备好，相当于一次「握手」
 ch1 := make(chan int)

 // 有缓冲 channel：容量为 5，缓冲不满时发送不阻塞
 ch2 := make(chan string, 5)

 // 只声明不 make 的 channel 是 nil channel
 var ch3 chan float64
 fmt.Println(ch3 == nil) // true（nil channel 不能收发，见 3.7）

 fmt.Println(ch1 == nil, ch2 == nil) // false, false
 _ = ch1
 _ = ch2
}

⚠️ C++ 对照：make(chan int) 既有「分配」又有「初始化」两层含义，像 std::make_shared<T>()。注意这里返回的是 channel 本身，不是一个指针——但你如果 ch2 := make(chan int) 再 ch2 = ch2，传递的都是同一个底层通道的引用，多个 goroutine 共享它时不需要再加锁。

CLI 工具 flag 与 cobra

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 Boost.Program_options / CLI11 到 Go：标准库 flag 包入门，再上手 cobra 这个事实标准的命令行框架

一、简述

命令行工具（CLI）是 Go 最擅长的领域之一：编译出来是单一静态二进制，启动快、分发简单，天然适合写 git / docker 这类开发者工具。Go 在命令行的「外挂」上做了很多设计——os.Args 给你原始参数，标准库 flag 包给你简单的 -name value 解析，而 spf13/cobra（Kubernetes、Hugo、Docker CLI 大量使用）则提供子命令、flag 继承、自动帮助和 shell 补全的完整方案。

核心要点：C++ 里解析命令行要么手写循环扫 argv，要么拉 Boost.Program_options / CLI11；Go 的路径是「标准库 flag 够用即用，复杂命令行直接上 cobra」。cobra 的「命令树」思想对 C++ 开发者来说很像「用对象组合搭一棵命令路由树」。

二、C++ 对照速查表

概念	C++	Go	关键差异
入口参数	`int main(int argc, char* argv[])`	`func main()` + `os.Args`	`os.Args[0]` 是程序名，Go 是切片可遍历
参数解析库	Boost.Program_options / CLI11	`flag`（标准库）	flag 零依赖，但功能简单
子命令框架	自己搭 / CLI11	`github.com/spf13/cobra`	cobra 是事实标准（k8s/gh/hugo 都用）
类型自动转换	`boost::lexical_cast`	flag 绑定即转换	`flag.Int` 自动转，无需显式 cast
帮助文本	手动拼接打印	flag / cobra 自动生成	`-h` / `--help` 开箱即用
长短选项	`-v` / `--verbose`	`-v` / `--verbose` 等价	flag 单双横线都认；布尔无需值
子命令树	无标准方案	cobra `AddCommand` 层层挂载	命令即对象，可嵌套
shell 补全	无标准方案	cobra `completion` 命令	生成 bash/zsh/fish 脚本
解析失败行为	抛异常 / 返回错误码	flag 默认 `ExitOnError`	可切换到 `ContinueOnError` 自己处理

三、逐主题详解

3.1 os.Args —— 原始参数切片

任何命令行的起点。和 C++ 的 argc/argv 相比，Go 把它做成了普通切片，不用数个数、不用指针算术：

CMake 工程模板：VS2022 + Boost（静态库）

Tue, 13 Oct 2026 00:00:00 +0000

这是一个可直接复制的 Boost 工程模板（VS2022 + CMake + Ninja）。模板的作用：新建 Boost 项目时不用每次从零配置——复制模板、改项目名、加源文件即可。整套约定是：CMake 为唯一构建系统、依赖走环境变量 + find_package、构建输出在 out/build/、不写死路径。

前置环境变量：

BOOST_ROOT = <Boost根目录>

Boost 是静态库（vc143 构建），不用加 PATH，运行时不需要 dll

一、目录结构

<项目根目录>\BoostTemplate\
├── CMakeLists.txt
├── CMakePresets.json
├── .gitignore
├── src\
│ └── main.cpp
└── out\
 └── build\

二、CMakeLists.txt（复制到项目根目录）

cmake_minimum_required(VERSION 3.20)
project(BoostTemplate LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# ---------- Boost ----------
# BOOST_ROOT 由 CMakePresets.json 从环境变量注入，这里不写路径
set(Boost_NO_SYSTEM_PATHS ON) # 只从 BOOST_ROOT 找，不扫系统路径
set(Boost_USE_STATIC_LIBS ON) # 用静态库（vc143 静态构建）
set(Boost_USE_MULTITHREADED ON) # 多线程版本

find_package(Boost 1.81 REQUIRED COMPONENTS filesystem system thread)

# ---------- 源文件 ----------
set(SOURCES
 src/main.cpp
)

add_executable(${PROJECT_NAME} ${SOURCES})

target_include_directories(${PROJECT_NAME} PRIVATE
 ${CMAKE_CURRENT_SOURCE_DIR}/src
)

target_link_libraries(${PROJECT_NAME} PRIVATE
 Boost::filesystem
 Boost::system
 Boost::thread
)

三、CMakePresets.json（复制到项目根目录）

{
 "version": 3,
 "configurePresets": [
 {
 "name": "debug",
 "generator": "Ninja",
 "binaryDir": "${sourceDir}/out/build/${presetName}",
 "cacheVariables": {
 "CMAKE_BUILD_TYPE": "Debug",
 "BOOST_ROOT": "$env{BOOST_ROOT}",
 "Boost_NO_SYSTEM_PATHS": "ON",
 "Boost_USE_STATIC_LIBS": "ON",
 "Boost_USE_MULTITHREADED": "ON"
 }
 },
 {
 "name": "release",
 "inherits": "debug",
 "cacheVariables": {
 "CMAKE_BUILD_TYPE": "Release"
 }
 }
 ],
 "buildPresets": [
 { "name": "debug", "configurePreset": "debug" },
 { "name": "release", "configurePreset": "release" }
 ]
}

版本待核实：预设文件 "version": 3 与 CMakeLists.txt 里 cmake_minimum_required(VERSION 3.20) 的版本要求是否匹配（version 3 预设需较新的 CMake），首次配置前请确认本机 / VS2022 自带 CMake 的实际版本。

CMake 工程模板：VS2022 + OpenCV 4.10

Tue, 13 Oct 2026 00:00:00 +0000

这是一个可直接复制的 OpenCV 工程模板（VS2022 + CMake + Ninja）。模板的作用：新建 OpenCV 项目时不用每次手动加 include/lib 路径——复制模板、改项目名、加源文件即可。整套约定是：CMake 为唯一构建系统、依赖走环境变量 + find_package、构建输出在 out/build/、不写死路径。

前置环境变量：

OpenCV_DIR = <OpenCV安装目录>\build\x64\vc16\lib

PATH 追加：<OpenCV安装目录>\build\x64\vc16\bin

一、目录结构

<项目根目录>\OpenCVTemplate\
├── CMakeLists.txt
├── CMakePresets.json
├── .gitignore
├── src\
│ └── main.cpp
└── out\
 └── build\

二、CMakeLists.txt（复制到项目根目录）

cmake_minimum_required(VERSION 3.20)
project(OpenCVTemplate LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# ---------- OpenCV ----------
# OpenCV_DIR 由 CMakePresets.json 从环境变量注入，这里不写路径
find_package(OpenCV REQUIRED)

# ---------- 源文件 ----------
set(SOURCES
 src/main.cpp
)

add_executable(${PROJECT_NAME} ${SOURCES})

target_include_directories(${PROJECT_NAME} PRIVATE
 ${CMAKE_CURRENT_SOURCE_DIR}/src
 ${OpenCV_INCLUDE_DIRS}
)

target_link_libraries(${PROJECT_NAME} PRIVATE
 ${OpenCV_LIBS}
)

三、CMakePresets.json（复制到项目根目录）

{
 "version": 3,
 "configurePresets": [
 {
 "name": "debug",
 "generator": "Ninja",
 "binaryDir": "${sourceDir}/out/build/${presetName}",
 "cacheVariables": {
 "CMAKE_BUILD_TYPE": "Debug",
 "OpenCV_DIR": "$env{OpenCV_DIR}"
 }
 },
 {
 "name": "release",
 "inherits": "debug",
 "cacheVariables": {
 "CMAKE_BUILD_TYPE": "Release"
 }
 }
 ],
 "buildPresets": [
 { "name": "debug", "configurePreset": "debug" },
 { "name": "release", "configurePreset": "release" }
 ]
}

版本待核实：预设文件 "version": 3 与 CMakeLists.txt 里 cmake_minimum_required(VERSION 3.20) 的版本要求是否匹配（version 3 预设需较新的 CMake），首次配置前请确认本机 / VS2022 自带 CMake 的实际版本。

context 超时取消与传值

Tue, 13 Oct 2026 00:00:00 +0000

C++ 没有直接对应的东西——它最接近 std::jthread 的 stop_token：一个穿过调用链的「取消令牌 + 截止时间 + 键值袋」

一、简述

context.Context（标准库 context 包）是 Go 并发中传播取消信号、截止时间与请求级数据的载体。它贯穿整个标准库（HTTP 请求、数据库、RPC），是每一个「可能被取消的耗时代码」的标配第一参数。

它解决 C++ 里三个长期痛点：

传递取消信号：深调用链中，任何一层想取消整条链，怎么办？C++ 用 std::atomic<bool> 到处传 + 检查，或 std::jthread 的 stop_token。Go 里就是 ctx.Done() + 广播。
传递截止时间：每个函数都检查「现在是不是超时了」很烦。Go 里 context.WithDeadline 一路带过去，子任务自己查 ctx.Done()。
传递请求级数据：分布式的 trace id、用户信息等「横切数据」，Go 用 WithValue 携带，避免每个函数都加参。

核心要点：context.Context 只做三件事：取消（Cancel）、截止（Deadline/Timeout）、传值（Value）。 它不是「任意全局状态袋」，不该往里塞业务对象；也不是给每个函数都强加的仪式，而是给「可能被取消的耗时代码」用的。

二、C++ 对照速查表

概念	C++	Go	关键差异
取消令牌	`std::stop_token` / 手写 `atomic<bool>`	`ctx.Done()` + 树形传播	Go 一次 cancel 广播整棵子树
超时取消	`std::stoptoken` + 手算时间	`context.WithTimeout(ctx, 3*time.Second)`	一行完成「到时自动 cancel」
截止时间	`steady_clock::now() + d` 自己算	`context.WithDeadline(ctx, t)`	Go 语义是绝对时刻
手动取消	手写 `atomic<bool>` + 到处检查	`cancelFunc()`（WithCancel 返回）	cancel 是「广播」，不只本层
关联请求数据	线程局部 / 全局 map（危险）	`context.WithValue(parent, key, val)`	Go 类型安全 + 随 ctx 走
goroutine 收尾	`jthread.request_stop()` + join	`select { case <-ctx.Done(): ... }`	Go 惯例：非主路径用 select 监听取消
取消原因	无	`ctx.Err()` → `context.Canceled` / `DeadlineExceeded`	区分「被取消」与「超时」
上下文传播	无（要么传 token，要么全局）	函数第一参数约定	Go 靠约定 + vet 检查不传 nil

三、逐主题详解

3.1 两个根：`context.Background()` 与 `context.TODO()`

package main

import (
 "context"
 "fmt"
)

func main() {
 // Background：程序的「根上下文」，所有 context 树的起点
 ctx := context.Background()
 fmt.Println("Background Err =", ctx.Err()) // nil（永远不会被取消）
 fmt.Println("Background Done =", ctx.Done()) // nil channel（永不关闭）

 // TODO：还没想好用哪个 context 时的占位，语义同 Background
 todo := context.TODO()
 fmt.Println("TODO 等价于 Background:", todo.Err() == nil)

 _ = ctx
 _ = todo
}

规则：

dsh-image-analyze

Tue, 13 Oct 2026 00:00:00 +0000

DSH（DeepSeek Harness）插件：让纯文本模型也能"看图"。 图片、截图、PDF、Word 文档——统一路由到视觉模型（默认 mimo-v2.5）分析，对话模型只负责文字推理。全程同一供应商契约，按需付费。

English · 中文

✨ 特性

能力	说明
🖼 四种图片入口	指定路径 / “分析最新截图”（免路径）/ 多张一次 / 桥接粘贴（配合 dsh-image-bridge）
📄 文档解析	PDF 逐页渲染（PyMuPDF）、Word(.docx) 解包内嵌图，一次送视觉模型分析
🎯 确定性视觉路由	视觉调用固定走同一供应商路由（`opencode-go`）+ 同一凭据，不引入第三方模型
💰 按需付费	只有真正看图时才产生视觉调用；`mimo-v2.5` 与主流文本模型同价
🔁 两种转述模式	`relay`（结构化视觉数据：OCR/布局/颜色/SVG）vs `direct`（视觉模型直接产出，零损耗）
🧹 空白截图自动跳过	小文件直跳 + PNG 像素方差检测，误触的空捕获不会浪费一次调用
📋 来源可见	每次分析返回"分析来源"清单，明确指出实际看了哪些文件
🔧 零依赖	插件本体纯 ESM、不 import 任何 `@deepseek-ai` 包，本地安装无需 npm registry；文档解析仅需系统 Python

🏗 架构与工作原理

┌─ 图片入口 ─────────────────────────────────────────────┐
│ ① 指定路径 "分析 D:\xx\img.png" │
│ ② 最新截图 "分析最新截图 / 最新两张截图"（免路径） │
│ ③ 粘贴桥接 dsh-image-bridge 落盘 → [图片附件] 标记 │
│ ④ 文档 "分析 D:\xx\doc.pdf / report.docx" │
└────────────────────────┬───────────────────────────────┘
▼
analyze_images / analyze_document 工具
│
┌────────────────┼──────────────────┐
▼ ▼ ▼
attachments ctx.llm.stream sources
(持久化图片) provider: opencode-go (来源报告)
model: mimo-v2.5
│
▼
relay 模式 → 结构化视觉数据（OCR/布局/颜色/SVG）→ 对话模型推理
direct 模式 → 视觉模型直接产出最终答案（如 HTML 复刻）

设计要点

encoding/json 与配置文件

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 nlohmann/json 到 Go 的 encoding/json：结构体标签驱动的序列化

一、简述

Go 的 encoding/json 是标准库内置的 JSON 序列化/反序列化包。与 C++ 需要第三方库（nlohmann/json、rapidjson）不同，Go 通过**结构体字段标签（struct tag）**声明式地描述 JSON 映射关系，json.Marshal / json.Unmarshal 一键完成转换。

核心要点：Go 的 JSON 哲学是"结构体即 schema"——先用结构体定义数据形状，标签控制字段名、可选性、忽略规则。这也让配置文件读写（JSON/YAML）变得极其自然。

二、C++ 对照速查表

概念	C++	Go	关键差异
JSON 库	nlohmann/json 等第三方	`encoding/json` 标准库	开箱即用
对象映射	`json j = json::parse(s)`	`json.Unmarshal(data, &v)`	需要目标结构体
序列化	`j.dump()`	`json.Marshal(v)`	返回 []byte + error
字段改名	手动构造	struct tag `json:"name"`	声明式
忽略字段	手动排除	`json:"-"`	标签控制
可选字段	无	`omitempty`	零值不输出
动态 JSON	`json::object()` / 数组	`map[string]any` / `[]any`	用 any 容器
配置文件	Boost.PropertyTree / YAML 库	读 JSON 或第三方 YAML（gopkg.in/yaml.v3）	JSON 为主

三、序列化与反序列化

3.1 基本用法

import (
 "encoding/json"
 "fmt"
)

type Person struct {
 Name string
 Age int
}

func main() {
 p := Person{Name: "Tom", Age: 30}

 // 序列化：结构体 → JSON
 data, err := json.Marshal(p)
 if err != nil {
 panic(err)
 }
 fmt.Println(string(data)) // {"Name":"Tom","Age":30}

 // 反序列化：JSON → 结构体
 var p2 Person
 err = json.Unmarshal(data, &p2)
 if err != nil {
 panic(err)
 }
 fmt.Printf("%+v\n", p2) // {Name:Tom Age:30}
}

3.2 结构体标签（关键）

type Config struct {
 Server string `json:"server"` // 字段名映射为 server
 Port int `json:"port"` // 默认 0
 Debug bool `json:"debug,omitempty"` // 零值时省略
 Secret string `json:"-"` // 永远不参与 JSON
 Tags []string `json:"tags,omitempty"` // 空切片省略
}

c := Config{Server: "localhost", Secret: "不输出"}
data, _ := json.Marshal(c)
fmt.Println(string(data)) // {"server":"localhost","port":0}（debug/tags 因 omitempty 省略，port 没有 omitempty 所以零值照样输出，secret 被 json:"-" 忽略）

标签规则：

GMP 调度模型

Tue, 13 Oct 2026 00:00:00 +0000

C++ 里你要手写线程池、任务队列、负载均衡；Go 用 G/M/P 三件套在运行时层面把它全包了

一、简述

goroutine 不是 OS 线程，它比线程轻几个数量级。让几十万 goroutine 复用少数几个内核线程的，就是本章主角——GMP 调度模型。学完你会明白：go func() 背后发生了什么、为什么 goroutine 能在系统调用阻塞时"让位"、GOMAXPROCS 到底是什么、以及 M:N 用户态协程调度器是如何设计的。

核心要点：G（goroutine，任务）、M（Machine，OS 线程，工人）、P（Processor，调度上下文，工位）。P 的数量才是真正同时跑的 “线程数”，G 挂在 P 的本地队列上排队执行，M 抢到 P 才干活。运行时自动完成了 C++ 里你手写线程池 + 任务队列 + work-stealing 的全部工作。

二、C++ 对照速查表

概念	C++	Go	关键差异
并发执行单元	`std::thread`	goroutine (G)	`std::thread` 直接映射 OS 线程，G 是用户态任务
线程池	自写 / `BS::thread_pool` 等	内置 GMP	Go 运行时自动复用 M，无需自建池
任务队列	`std::queue<std::function>` + mutex	P 本地队列 runq	每个 P 有 256 长的本地队列，另有全局限队列
线程数量	自己定 / `std::thread::hardware_concurrency`	`GOMAXPROCS`（默认 = CPU 核数）	P 的数量决定并行度，M 可多于 P
线程阻塞迁移	无自动机制	M 阻塞时 P 移交	系统调用/锁阻塞时，P 被交给其它 M 继续执行 G
栈	固定大小（默认 1~8MB）	初始 2KB，动态增长	G 栈可扩容，按需分配
让出 CPU	无（靠 OS 时间片）	`runtime.Gosched()`	G 主动让出 P，避免饿死其它 G
抢占	内核时间片抢占	运行时信号抢占（Go 1.14+）	协作式 + 抢占式混合
work-stealing	手写	内置	空闲 P 偷其它 P 的队列任务，均衡负载
主线程	`int main()`	`m0` + `g0`	运行时专用线程和调度 goroutine

三、逐主题详解

3.1 三个字母分别是什么

┌──────────────────────────────────────────────────────────────┐
│ GMP 关系示意 │
│ │
│ G (goroutine) M (machine) P (processor) │
│ ┌──────┐ ┌───────┐ ┌─────────────┐ │
│ │ 用户 │ │ 内核 │ │ 调度上下文 │ │
│ │ 代码 │──调度于──→ │ OS线程 │──绑定于──→│ 本地队列 │ │
│ │ 栈G │ │ 栈M │ │ runq[256] │ │
│ └──────┘ └───────┘ └─────────────┘ │
│ 任务 工人 工位 │
└──────────────────────────────────────────────────────────────┘

G（goroutine）：一个待执行的函数 + 它的栈 + 上下文（寄存器现场）。创建的每个 go func() 都对应一个 G。它只是任务元数据，不是执行载体。G 结构体字段很长（src/runtime/runtime2.go），核心有栈描述 stack、当前函数 sched（保存 PC/SP）、状态 atomicstatus、所属 P 的指针、是否可被抢占等。
M（Machine）：真实的 OS 线程，由内核调度。M 负责真正执行 G 的机器码。创建 M 要付出系统调用成本（约 1MB 内核栈 + 内核结构，线程栈），远贵于创建 G。M 通常不超过几千个，且有上限（受系统资源约束，默认 maxmcount=10000）。
P（Processor）：你可以把它理解成"工位/许可令牌"。P 里有本地可运行队列 runq（长度 256）。G 想被调度运行，必须先被放进某个 P 的 runq，然后 P 绑定到某个 M 上执行队列里的 G。
P 的数量 = GOMAXPROCS（默认取 CPU 逻辑核数），它决定了同一时刻真正并行执行的 goroutine 上限。P 多了，并行度就高；P = 1 时行为接近单线程。

C++ 对照：M ≈ 一个真正运行在 CPU 上的线程；P ≈ 每个线程手头那个任务队列；G ≈ 任务队列里的任务项。你写线程池时是"一个线程，抢全局任务队列"，Go 优化成"每线程一队列 + 偷取"，减少锁竞争。

go mod 依赖管理

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 CMake+Conan/vcpkg 到 Go modules：官方集成、语义化版本与可复现构建

一、简述

Go 自 1.11 起引入 Go modules（常称 go mod）作为官方依赖管理工具，1.16 起默认启用。它把「依赖管理」内置到工具链里，一个 go.mod 文件声明模块与依赖，go.sum 锁定依赖的校验和，配合**语义化版本（v1.2.3）**和 GOPROXY 代理，实现可复现构建。

对于 C++ 开发者，可以把它理解为「CMake + Conan/vcpkg + 包清单 + 锁文件的四合一」：go.mod ≈ CMakeLists.txt + conanfile.txt，go.sum ≈ 锁文件，go get ≈ conan install，replace 指令 ≈ CMake 的本地路径引入。

核心要点：Go modules 不是「又一个包管理器」，而是语言官方、零配置文件的依赖解决方案。理解 go.mod 的四个指令（module / go / require / replace）就掌握了 90% 的日常操作。

二、C++ 对照速查表

概念	C++	Go	关键差异
构建系统	CMake / Makefile	`go build`（内建）	无需写构建脚本
依赖清单	`conanfile.txt` / `vcpkg.json`	`go.mod`	官方格式，随项目同时维护
依赖安装	`conan install` / `vcpkg install`	`go get` / `go mod tidy`	不装到系统，进模块缓存
锁文件	Conan `conan.lock`（可选）	`go.sum`	默认生成，锁定每行依赖版本+校验和
本地路径依赖	`target_link_libraries` 指向源码目录	`replace ... => ../xxx`	官方一等公民指令
语义化版本	Conan `[requires] pkg/1.2.3`	`v1.2.3`（标签含 `v` 前缀）	Go 的版本就是 git tag
代理/镜像	自建 Artifactory / Nexus	`GOPROXY`（如 goproxy.cn）	环境变量即可切换，无需配置仓库
私有仓库	CMake `FetchContent` + SSH	`GOPRIVATE` + git	绕过代理直连
缓存目录	Conan 本地 cache	`$GOPATH/pkg/mod`	全局共享，只读
vendor 机制	把第三方源码拷进仓库	`go mod vendor`	可选但常用，利于离线构建

三、逐主题详解

3.1 module 与 go.mod 三大字段

在项目根目录运行 go mod init 生成 go.mod：

Go 内存模型：happens-before

Tue, 13 Oct 2026 00:00:00 +0000

C++ 有 std::atomic + 内存序（memory_order），Go 有更少的口子但边界更清楚——channel / Mutex / Once / atomic 各自建立 happens-before

一、简述

“变量加了锁就不会有竞态"这种直觉在并发世界里是危险的。真正需要回答的问题是：goroutine A 写了一个值，goroutine B 什么时候能确定读到它？ Go 用一份官方文档——The Go Memory Model——精确规定了这些"什么时候”。它定义了 happens-before 关系：同步原语（channel、Mutex、WaitGroup、Once、atomic）在收发/加解锁/等待/原子操作之间建立序，从而保证内存可见性。理解它，你才知道为什么"不加同步 flag 读 bool"可能读到旧值，也才知道怎么写出不靠运气的并发程序。

核心要点：happens-before（HB）是"一个事件必须在另一个事件之前发生且其结果可见"的形式化保证。Go 的并发正确性全部建立在"你用了某个同步原语，它就给你对应的一条 HB 边"上。不用原语 = 没有边 = 编译器/硬件随便重排。

二、C++ 对照速查表

概念	C++	Go	关键差异
内存模型文档	`[memory_order]` 标准章节	The Go Memory Model（官方文档）	C++ 需要你精确选 memory_order；Go 不给选项，只规定用了哪个同步原语获得哪条 HB 边
互斥锁	`std::mutex` 加锁/解锁	`sync.Mutex` Lock/Unlock	C++ 还要额外配 `atomic` 才能安全读共享变量；Go 锁内一切可见
放松内存序	`memory_order_relaxed`	无对应概念	Go 只有两档：同步原语→对应 HB 保证，非同步→无保证
原子操作	`std::atomic<T>`（load/store/fetch等）	`sync/atomic`	Go 1.19 之前 atomic 只防撕裂不建 HB；1.19+ 视作同步点
初始化一次	`std::once_flag`	`sync.Once`	`once.Do` 完成后，所有 `Do` 返回点看到其写入
线程等待	`std::thread::join`	`sync.WaitGroup.Wait`	`Wait` 返回后看到各 `Done` 的写入
通信同步	`mutex`+`cv` 手写	channel	收发建立 HB，官方推荐优先 channel
主动读屏障	`atomic_thread_fence`	无直接对应	Go 用 `atomic.Load`/互斥代替 fence
悬而未决的"下次可见"	无	“稍后某个时刻可见"是合法但无保证	这是最常见的 bug 来源
数据竞争检测	TSan（第三方）	`go test -race` 内建	干干净净的"竞态即报”

三、逐主题详解

3.1 你已经在 C++ 里见过的"序"

C++ 的 memory_order 有三种强度：relaxed（无序）、acquire/release（只保证可见但不能越过）、seq_cst（全局一致）。Go 的模型把选择收敛成一条规则：

Go 语言学习路线（C++ 开发者视角）

Tue, 13 Oct 2026 00:00:00 +0000

1. 学习定位与目标
2. 从 C++ 到 Go 的思维转换
3. 阶段一：基础语法（第 1~2 周）
4. 阶段二：语言进阶（第 3~4 周）
5. 阶段三：并发编程（第 5~6 周）
6. 阶段四：工程化与工具链（第 7~8 周）
7. 阶段五：实战项目
8. 阶段六：深入内幕（进阶）
9. 推荐资源
10. 总结

1. 学习定位与目标

核心要点：Go 是为并发与工程效率而生的语言。它不是 C++ 的替代品，而是面向网络服务、云原生、分布式系统场景的现代选择。有 C++ 基础意味着你已经懂内存、指针、编译原理、并发难点——这些沉淀可以让你学 Go 的速度远超零基础者。

1.1 为什么学 Go

优点	说明
语法极简	没有类继承、泛型魔法（1.18 才加）、运算符重载，几小时能读完语法
编译快	没有模板实例化与复杂的 ODR，编译速度接近 C 语言
并发内建	goroutine + channel 是语言级能力，不是库
部署简单	静态编译，单个可执行文件，天然适合容器/云原生
标准库强大	网络、JSON、加密、压缩开箱即用，生态围绕服务端
工具链统一	官方格式化、测试、文档、依赖管理一条龙

1.2 对 C++ 开发者，Go 最大的"爽点"

没有内存泄漏焦虑：GC 自动回收，专注业务逻辑。
没有头文件割裂：一个 .go 文件即一个单元，import 即用。
没有 build 时间长：秒级编译。
没有模板错误地狱：泛型报错可读性好得多。

2. 从 C++ 到 Go 的思维转换

核心要点：这一节是全篇最关键的部分。C++ 功底在 Go 里既是资产也是包袱——资产是并发、内存模型、数据结构的直觉；包袱是"继承 + 异常 + 手动内存"的思维定式，需要刻意转换。

goroutine

Tue, 13 Oct 2026 00:00:00 +0000

Go 并发的基本执行单元：比线程轻量十倍的绿色协程，由 Go 运行时调度

一、C++ 对照速查表

概念	C++	Go	关键差异
并发执行单元	`std::thread`	`go func()`	goroutine 由运行时管理，不映射到 OS 线程
创建成本	~1MB 栈 + 系统调用	~2KB 栈，动态增长	goroutine 创建成本极低，可轻松创建上万
启动方式	`std::thread t(func); t.join();`	`go func()`	Go 无需手动 join，用 channel/WaitGroup 同步
调度模型	1:1 映射 OS 线程	M:N 调度（GMP 模型）	运行时把 N 个 goroutine 调度到 M 个线程上
栈大小	固定（通常 1~8MB）	初始 2KB，按需增长/收缩	同一地址空间下可容纳海量 goroutine
终止方式	thread 析构或 detach	主 goroutine 结束则全部退出	goroutine 是 “fire and forget”

核心要点：goroutine 是 Go 并发的基石。创建一个 goroutine 只用一个 go 关键字，运行时自动处理调度、栈管理和线程复用。但 goroutine 之间需要通过 channel 或 sync 包 同步，否则会出现数据竞争。

Map（哈希表）

Tue, 13 Oct 2026 00:00:00 +0000

Go 的内置关联容器，键值对存储，底层是哈希表

一、概述

map 是 Go 的内置数据结构，用于存储键值对。它等价于 C++ 的 std::unordered_map——基于哈希表实现，不是红黑树（Go 没有 std::map 那样的有序容器）。

核心特性：

引用类型，赋值和传参共享底层数组
键必须支持 == 比较（可哈希）
遍历顺序不确定（哈希表特性）
并发读写会触发 fatal（不是 data race，直接崩程序）

二、C++ 对照速查表

Go	C++	说明
`map[K]V` 类型声明	`std::unordered_map<K,V>` 类型声明	声明一个 map 类型
`m := map[string]int{}`	`auto m = unordered_map<string,int>();`	字面量初始化
`m := make(map[string]int)`	`auto m = unordered_map<string,int>();`	make 初始化
`m := make(map[string]int, 64)`	`auto m = unordered_map<string,int>(64);`	预分配容量
`m["key"] = 42`	`m["key"] = 42;`	插入/修改
`delete(m, "key")`	`m.erase("key");`	删除键
`val, ok := m["key"]`	`auto it = m.find("key"); it != m.end()`	查找（双返回值）
`len(m)`	`m.size()`	获取大小
`nil map`	`nullptr` 的 map	未初始化的 map
`for k, v := range m`	`for (auto& [k, v] : m)`	遍历
无	`std::map<K,V>`	Go 没有有序 map

三、声明与初始化

3.1 字面量初始化（最常用）

package main

import "fmt"

func main() {
 // 字面量初始化：声明 + 赋值一步到位
 ages := map[string]int{
 "Alice": 30,
 "Bob": 25,
 "Carol": 28,
 }
 fmt.Println(ages) // map[Alice:30 Bob:25 Carol:28]

 // 空 map
 empty := map[string]int{}
 fmt.Println(len(empty)) // 0
}

3.2 make 初始化

// make 创建空 map，可选预分配容量（提高性能）
scores := make(map[string]int) // 零值容量
scores2 := make(map[string]int, 64) // 预分配 64 个槽位

// 适用场景：已知大致大小，预分配可减少扩容次数
users := make(map[int]string, 1000)

3.3 nil map（未初始化）

var m map[string]int // nil map，值为 nil
fmt.Println(m) // map[]
fmt.Println(len(m)) // 0 — len 对 nil map 返回 0

3.4 C++ 对照

Go	C++
`ages := map[string]int{"Alice": 30}`	`auto ages = unordered_map<string,int>{{"Alice", 30}};`
`m := make(map[string]int)`	`auto m = unordered_map<string,int>();`
`m := make(map[string]int, 64)`	`auto m = unordered_map<string,int>(64);`
`var m map[string]int` (nil)	`unordered_map<string,int>* m = nullptr;`

四、增删改查

4.1 增 / 改（赋值）

m := map[string]int{}

// 不存在的 key → 插入
m["apple"] = 5
m["banana"] = 3

// 已存在的 key → 修改
m["apple"] = 10

fmt.Println(m) // map[apple:10 banana:3]

4.2 查（双返回值 ok 模式）

m := map[string]int{"x": 1, "y": 2}

// 双返回值：值 + 是否存在（ok 模式）
val, ok := m["x"]
fmt.Println(val, ok) // 1 true

val2, ok2 := m["z"]
fmt.Println(val2, ok2) // 0 false（零值，不存在）

// C++ 对比：
// auto it = m.find("x");
// if (it != m.end()) { /* 找到 */ }

为什么需要 ok 模式？ 如果值类型是 int，零值是 0，无法区分"值为 0"和"不存在"。ok 布尔值解决了这个问题。

OpenCV 4.10 + Visual Studio 环境配置：属性页手动配法

Tue, 13 Oct 2026 00:00:00 +0000

在 Visual Studio 项目里用属性页手动配置 OpenCV 4.10 的完整步骤：包含目录、库目录、链接器输入、环境变量，四步配好后用一段自检代码验证。（如果用 CMake 工程，则改为环境变量 + find_package 的方案，不用逐项目配属性页。）

一、配置步骤

1. 包含目录

项目属性 → VC++ 目录 → 包含目录，添加：

<OpenCV安装目录>\build\include

2. 库目录

项目属性 → VC++ 目录 → 库目录，添加：

<OpenCV安装目录>\build\x64\vc16\lib

vc16 对应 Visual Studio 2019/2022

3. 链接器输入

项目属性 → 链接器 → 输入 → 附加依赖项，添加：

opencv_world4100.lib

4. 环境变量

系统环境变量 Path 中添加：

<OpenCV安装目录>\build\x64\vc16\bin

二、验证

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
 std::cout << "OpenCV Version: " << CV_VERSION << std::endl;
 return 0;
}

三、常见问题

运行时弹出找不到 dll → 检查环境变量是否配置正确
链接错误 → 检查库目录和附加依赖项
Release / Debug 库混用 → Debug 构建须链接带 d 后缀的 opencv_world4100d.lib，Release 用 opencv_world4100.lib

OpenCV 常用 API：图像读写、显示与颜色空间转换

Tue, 13 Oct 2026 00:00:00 +0000

OpenCV 入门最常用的几组 API：图像读取、显示、颜色空间转换、保存、获取图像信息。

一、图像读取与显示

#include <opencv2/opencv.hpp>
using namespace cv;

int main() {
 // 读取图像
 Mat img = imread("test.jpg");

 // 显示图像
 imshow("窗口名", img);

 // 等待按键
 waitKey(0);

 return 0;
}

二、灰度图转换

Mat gray;
cvtColor(img, gray, COLOR_BGR2GRAY);
imshow("灰度图", gray);

三、HSV 图像转换

Mat hsv;
cvtColor(img, hsv, COLOR_BGR2HSV);
imshow("HSV", hsv);

四、常用颜色空间

转换	常量
BGR → 灰度	`COLOR_BGR2GRAY`
BGR → HSV	`COLOR_BGR2HSV`
BGR → RGB	`COLOR_BGR2RGB`
灰度 → BGR	`COLOR_GRAY2BGR`

五、图像保存

imwrite("output.jpg", gray);

六、获取图像信息

int width = img.cols; // 宽度
int height = img.rows; // 高度
int channels = img.channels(); // 通道数

OpenCV 像素遍历：at<> 与 ptr<> 两种方式对比

Tue, 13 Oct 2026 00:00:00 +0000

OpenCV 访问像素的两种方式：at<> 直接访问和 ptr<> 指针访问。

一、方式一：at<> 直接访问

通过行列索引直接访问像素，代码简洁但每次访问都有边界检查开销。

// 单通道（灰度图）
uchar pixel = image.at<uchar>(i, j);
image.at<uchar>(i, j) = 255 - pixel;

// 三通道（彩色图）
Vec3b pixel = image.at<Vec3b>(i, j);
pixel[0] = 255 - pixel[0]; // B
pixel[1] = 255 - pixel[1]; // G
pixel[2] = 255 - pixel[2]; // R
image.at<Vec3b>(i, j) = pixel;

二、方式二：ptr<> 指针访问

获取行首指针后直接偏移，性能更优（无边界检查）。

// 单通道
uchar* rowPtr = image.ptr<uchar>(i);
rowPtr[j] = 255 - rowPtr[j];

// 三通道
Vec3b* rowPtr = image.ptr<Vec3b>(i);
Vec3b pixel = rowPtr[j];
pixel[0] = 255 - pixel[0];
pixel[1] = 255 - pixel[1];
pixel[2] = 255 - pixel[2];
rowPtr[j] = pixel;

三、对比

特性	at<>	ptr<>
语法	简洁直观	需理解指针
性能	每次边界检查，较慢	无边界检查，较快
适用	小批量访问、调试	大图遍历、性能敏感

四、反转图像示例（完整）

void invertImage(Mat& image) {
 int w = image.cols;
 int h = image.rows;
 int channels = image.channels();

 for (int i = 0; i < h; i++) {
 uchar* rowPtr = image.ptr<uchar>(i);
 for (int j = 0; j < w * channels; j++) {
 rowPtr[j] = 255 - rowPtr[j];
 }
 }
 imshow("Inverted", image);
}

可用 rowPtr[j] = 255 - rowPtr[j] 一次处理所有通道，无需区分通道数。

pprof 性能调优

Tue, 13 Oct 2026 00:00:00 +0000

C++ 里要弄 4~5 套工具（perf / valgrind / gprof / TSan）；Go 把 CPU、内存、goroutine、锁的剖面图都装进了一个 pprof

一、简述

性能调优第一步永远不是"猜"，是"量"。Go 的 pprof（profile）机制提供一套统一的剖析框架：CPU、堆内存、分配、goroutine、锁竞争、阻塞延时的剖面数据，既能离线抓（runtime/pprof、go test -cpuprofile），也能在线实时抓（net/http/pprof）。配合 go tool pprof 的 top / list / peek / web 交互和火焰图，你能在几分钟内定位 CPU 热点、内存黑洞、goroutine 泄漏。对用惯 perf/valgrind/gprof 的 C++ 开发者来说，这是一次"多工具合一"的升级。

核心要点：pprof 是采样式剖析：按频率打断程序，记录当时正在执行的函数调用栈，最后统计"每个函数在多少样本里出现"。flat 是"函数自己耗的"，cum 是"含它调用的所有子函数"——读懂这两个数字是使用 pprof 的核心。

二、C++ 对照速查表

概念	C++	Go	关键差异
CPU 剖析	`perf record/report`	`runtime/pprof` + `cpu.prof`	Go 内置采样器，无需 perf_event 权限
堆内存剖析	`valgrind --tool=massif` / `heaptrack`	`memprofile` + heap view	pprof 同时给 inuse/alloc 两维度
线级热点	`perf annotate`	`go tool pprof -list`	直接给源码行统计
火焰图	`perf script` + 第三方 FlameGraph	`go tool pprof -http`（内链火焰图）	一命令内建
死锁/锁竞争	手写 + `helgrind`	mutex/block profile	并发调优必备
调用图	`gprof`（编译期插桩）	pprof 自动采样	Go 无插桩成本，直接采样
内存泄漏排查	`valgrind --leak-check`	goroutine profile + `alloc_objects`	Go 看"分配来源"而非"泄漏点"
运行中抓取	需 `perf` 权限/SAMPLING	`net/http/pprof` 一键开	线上服务开端口即可

三、逐主题详解

3.1 profile 是什么：采样式剖析

时间轴 ──────────────────────────────────────────►
采样点：每隔 t（如 100 次/秒 = 10ms）触发 SIGPROF
每次记录：当前 goroutine 的完整调用栈（PC → 函数名）
┌────┐┌────┐┌────┐┌────┐
│foo ││bar ││foo ││baz │ 每个采样点保留栈帧
│ main││ foo││ main││ foo │ 最后统计: foo 出现 3/4 次
└────┘└────┘└────┘└────┘

CPU profile：默认每 10ms（100Hz）采样一次正在执行的 G 的栈。只有"在 CPU 上运行"的 G 会被采到——所以纯 IO/阻塞的 goroutine 在 CPU profile 里很低。
heap profile：不是采样，是快照。记录"当前存活对象"的分配点（用于看内存滞留）或"累计分配"（-alloc_space/-alloc_objects，用于看分配大山）。
goroutine profile：每个 goroutine 当前栈（含状态），看泄漏。
mutex/block profile：记录锁等待与阻塞事件（需要 runtime.SetBlockProfileRate / SetMutexProfileFraction 开启）。

3.2 离线抓取：`runtime/pprof` 与 `go test -profile`

方式一：go test 直接出谱（最常用）

QMovie 动画播放

Tue, 13 Oct 2026 00:00:00 +0000

QMovie 是 Qt 中用于播放动画（主要是 GIF 格式）的类。它本身不是一个控件，不能直接显示在界面上，通常需要借助 QLabel（或 QGraphicsView）来展示播放效果。

它的核心作用是：逐帧读取动图文件，按时间间隔把每一帧渲染出来，从而实现动画播放。

1. 效果演示

通过 QLabel 显示一个加载中的 GIF 动画，并提供「开始 / 暂停 / 停止」三个按钮，演示 QMovie 的常用接口。

2. 属性和方法

QMovie 的工作流程大致是：加载文件 → 启动播放 → 播放结束。常用的属性和方法如下。

2.1 构造与加载

// 通过文件名构造
QMovie(const QString &fileName, const QByteArray &format = QByteArray(), QObject *parent = nullptr);

// 通过 QIODevice 构造（可用于资源文件、网络数据等）
QMovie(QIODevice *device, const QByteArray &format = QByteArray(), QObject *parent = nullptr);

// 设置 / 获取动画的文件名
void setFileName(const QString &fileName);
QString fileName() const;

// 判断动画是否有效（文件是否能被正确解析）
bool isValid() const;

2.2 播放控制

// 开始播放
void start();

// 暂停 / 继续(QMovie 没有 pause()/resume(),只有这个开关式接口,且它是一个槽)
void setPaused(bool paused); // true 为暂停，false 为继续
// 没有 paused()/isPaused() 这样的查询方法，是否暂停用 state() 判断
MovieState state() const; // NotRunning / Paused / Running

// 停止播放，并回到第一帧
void stop();

// 缓存模式
CacheMode cacheMode() const;
void setCacheMode(CacheMode mode);

QMovie 提供的播放控制比较简单，注意 stop() 与 setPaused(true) 的区别：

QSlider滑动条

Tue, 13 Oct 2026 00:00:00 +0000

本文搬运转载自明王讲QT - QSlider，仅供学习记录使用。版权归原作者所有。

QSlider 滑动条控件

QSlider是滑动条控件它允许用户通过拖动滑块来选择一个范围内的值。通常用于调整音量、亮度、进度等需要连续数值输入的场景

1. 效果演示三个滑动条，分别用来调节`RGB`三个颜色的值，并显示到左侧各自的文本框中

并且将RGB这三个颜色的组合，来设置上面的文本框的背景颜色

2. 属性和方法`QSlider`继承自`QAbstractSlider`，它的绝大多数属性都是从`QAbstractSlider`继承而来的。

QSlider有很多属性，完整的可查看帮助文档。这里仅列出常用的属性和方法

2.1 值滑动条和值相关的属性包括：当前值、最大值、最小值

// 获取和设置当前值
int value() const;
void setValue(int);

// 获取和设置最大值
int maximum() const;
void setMaximum(int);

// 获取和设置最小值
int minimum() const;
void setMinimum(int);

// 一次设置最大值和最小值
void setRange(int min, int max)

2.2 方向`Qt`中滑动条有水平滑动条和垂直滑动条之分，通过修改`orientation`属性来设置

// 获取和设置滑动条的方向
Qt::Orientation orientation() const;
void setOrientation(Qt::Orientation);

2.3 步长步长是指滑动条一次增加或减少的值。这里又包括两个步长：

singleStep：是指按键盘的左右箭头（←/→）时的步长
pageStep：是指点击滑块两侧时的步长

// 获取和设置singleStep
int singleStep() const;
void setSingleStep(int);

// 获取和设置pageStep
int pageStep() const;
void setPageStep(int);

2.4 刻度线```cpp

// 获取和设置刻度线间隔 int tickInterval() const void setTickInterval(int ti)

// 获取和设置刻度线的位置 QSlider::TickPosition tickPosition() const void setTickPosition(QSlider::TickPosition position)

Qt Model/View 架构详解 — Item Model 体系

Tue, 13 Oct 2026 00:00:00 +0000

一、架构总览

Qt 的 Model/View 架构是对经典 MVC 模式的实现与改造：

层级	职责	对应类
Model（数据源）	存储数据、提供数据访问接口	QAbstractItemModel 系列
View（视图）	显示数据、处理用户交互	QTableView, QTreeView, QListView
Delegate（委托）	自定义渲染和编辑	QStyledItemDelegate

核心思想：数据（Model）与展示（View）完全解耦，同一个 Model 可以同时被多个 View 显示。

二、类继承体系

QObject
└── QAbstractItemModel ← 所有 Item Model 的根基类
├── QAbstractListModel ← 简单一维列表的抽象基类
│ └── QStringListModel
├── QAbstractTableModel ← 二维表格的抽象基类(自己写表模型时继承它)
├── QStandardItemModel ← 开箱即用的通用模型（树/表/列表通吃）
└── SQL 模型是三级单链,不是从 QAbstractTableModel 派生:
QAbstractItemModel → QSqlQueryModel → QSqlTableModel → QSqlRelationalTableModel

其他直接从 QAbstractItemModel 派生的专用模型：

QFileSystemModel — 文件系统树

三、核心索引系统：QModelIndex

Model/View 的通信枢纽是 QModelIndex（模型索引）。

Qt MVC 与达梦数据库集成

Tue, 13 Oct 2026 00:00:00 +0000

电力设备运维场景：变电站设备经 IEC 104 规约报文上送遥测/遥信数据，Qt 后台接收解析后写入达梦数据库，界面用 Qt Model/View（MVC）框架展示。数据库部分讲解详细，全程与 MySQL 对比。

一、场景背景

业务链路：

变电站设备 --(IEC 104 报文)--> Qt 后台 TCP 服务端 --> 报文解析
--> 达梦数据库(DM8) --> QSqlTableModel --绑定--> QTableView 界面

遥测（YC）：电流、电压、功率等模拟量，周期上送。
遥信（YX）：开关位置、刀闸状态等开关量，变位上送。

本篇定位：MVC 基础原理（QModelIndex/Role/Delegate 机制）已在 ../Qt/Qt_ModelView_MVC架构详解.md 详细讲解，本篇不重复，重点放在数据库侧：达梦连接、三种数据库 Model 的用法、报文落库与界面刷新的完整链路。

二、达梦连接配置（详细）

2.1 为什么 Qt 用 ODBC 连接达梦

对比项	达梦 DM8	MySQL
Qt 驱动	无官方原生驱动，走 ODBC（`QODBC`）	官方 `QMYSQL` 驱动
端口	5236	3306
驱动来源	达梦安装目录自带 ODBC 驱动（`drivers/odbc/` 下）	Qt 编译时编译 qsqlmysql 插件

MySQL 有 QMYSQL 驱动，直接 QSqlDatabase::addDatabase("QMYSQL") 即可。达梦没有对应的 Qt 原生驱动，只能通过微软 ODBC 或 unixODBC 桥接，Qt 侧统一使用 QODBC。

Qt 架构阅读方法：从构造函数入手

Tue, 13 Oct 2026 00:00:00 +0000

看 Qt 桌面程序，不要从头文件按顺序"从小往大"看——Qt 没有顺序这一说，要从主页面构造函数去总结架构。

一、核心观点

Qt 程序（尤其带界面的桌面应用）里，构造函数是"所有功能的展示"：

成员初始化
资源/数据加载函数
功能函数（布局、控件创建、业务初始化）
信号与槽连接（最重要）

想看懂某一个页面的功能大局，步骤是：

看构造函数 → 看构造函数里的注释 → 找被调用的实现方法
→ 看"哪些被使用了、有什么用" → 再去对应头文件/源文件看定义
→ 看懂

而不是：打开一个头文件，从头到尾按声明顺序啃。

二、为什么 Qt 不能"从头文件按顺序看"

误区	原因
按头文件声明顺序读	头文件只是声明集合，不含调用关系；顺序 ≠ 执行顺序
从最小的类看起	小类之间没有依赖线索，看完全部也不懂"为什么存在"
先读业务函数	不知道它被谁调用、在什么时机触发（信号槽是异步/解耦的）
想找"程序入口→顺序执行"	Qt 是事件驱动的，没有线性执行流

Qt 程序的"执行顺序"不是代码顺序，而是：

main() 里创建主窗口 → 执行构造函数
构造函数一次性搭好：界面、数据、连接
之后程序进入事件循环，靠信号槽响应——调用关系藏在构造函数里

所以构造函数 = 架构入口，是唯一能"一览全局"的地方。

三、构造函数里到底有什么

以常见主窗口为例：

MainWindow::MainWindow(QWidget *parent)
 : QMainWindow(parent)
{
 // 1. 窗口属性初始化
 setWindowTitle("示例程序");
 resize(800, 600);

 // 2. 加载函数：资源、配置、数据
 loadConfig(); // 读配置文件
 initDatabase(); // 连接数据库
 setupToolbar(); // 加载图标/工具栏

 // 3. 功能函数：创建控件与布局
 createCentralWidget();
 createStatusBar();
 createMenu();

 // 4. ⭐ 信号与槽连接（核心：把"谁"和"谁"绑起来）
 connect(ui->startBtn, &QPushButton::clicked,
 this, &MainWindow::onStart);
 connect(this, &MainWindow::dataReady,
 ui->table, &TableWidget::refresh);
 connect(timer, &QTimer::timeout,
 this, &MainWindow::updateStatus);
}

构造函数 = 组装说明书：

Qt 网络编程 01：TCP 客户端与服务端（第一天）

Tue, 13 Oct 2026 00:00:00 +0000

适用版本：Qt 6.9 / MinGW / C++17 更新日期：2026-08-19 源码位置：<你的工程目录>\net（TcpSocket / Tcpserver / TCP_Client / TCP_Server 四个项目）

一、今天做了什么
二、项目清单与角色分工
三、准备工作：.pro 加 network 模块
四、控制台版：客户端 TcpSocket
五、控制台版：服务器 Tcpserver（多客户端广播）
六、GUI 版：TCP_Client
七、GUI 版：TCP_Server
八、核心知识点总结
九、今天踩的坑 / 值得注意的点
十、进阶写法：多客户端封装 ClientConnection 模式
十一、明天可以做什么

一、今天做了什么

用 Qt 实现了 TCP 客户端 / 服务器 双向通信，共 4 个项目：

项目	类型	角色	特点
`TcpSocket`	控制台（QCoreApplication）	客户端	连接即自动发一条 “Hello Server!”
`Tcpserver`	控制台（QCoreApplication）	服务器	多客户端 + 广播
`TCP_Client`	GUI（QWidget）	客户端	界面输入 IP/端口，收发消息
`TCP_Server`	GUI（QWidget）	服务器	界面选择端口，收发消息

我已有 Qt 基础，但网络编程是零基础。今天的关键收获是建立了"客户端/服务器"模型和 Qt 异步收发的心智模型。

Qt 网络编程学习路线（网络编程零基础视角）

Tue, 13 Oct 2026 00:00:00 +0000

适用人群：已掌握 Qt 基础（信号槽、事件循环、QWidget），网络编程零基础 适用版本：Qt 6.x（Qt 5 大部分通用）更新日期：2026-08-19

1. 学习定位与目标
2. 网络编程零基础必须先懂的 6 个概念
3. 阶段一：TCP 编程入门（第 1~2 周）
4. 阶段二：TCP 深入与实战化（第 3~4 周）
5. 阶段三：UDP 编程（第 5 周）
6. 阶段四：HTTP 与高层网络（第 6~7 周）
7. 阶段五：进阶与安全（第 8 周起）
8. 阶段六：实战项目
9. 推荐资源
10. 总结

1. 学习定位与目标

核心要点：你的 Qt 基础（信号槽、事件循环、对象树）是最大的优势——Qt 把网络编程封装成了"发信号 + 收信号"，你要补的不是 C++ 网络 API，而是网络协议的基本概念。

1.1 为什么用 Qt 学网络编程

优势	说明
异步事件驱动	收发数据都靠信号槽触发，不用自己写多线程阻塞 IO
跨平台	Windows / Linux / Android 同一套代码
高层封装	QTcpSocket / QUdpSocket / QNetworkAccessManager 把 socket API 包装成 Qt 风格
与 GUI 天然结合	收发数据直接刷新界面，客户端/服务器程序最容易做出可视化效果

1.2 和 C++ 原生 socket 的对比

原生 C++（Winsock / POSIX）	Qt 封装
`socket()` / `bind()` / `listen()` / `accept()`	`QTcpServer::listen()` / `nextPendingConnection()`
`connect()` / `send()` / `recv()`	`QTcpSocket::connectToHost()` / `write()` / `readAll()`
阻塞线程等待，需多线程处理	信号槽异步通知，事件循环驱动
手动管理缓冲区、错误码	`readyRead` 信号 + `readAll()`，`errorString()`

结论：先学概念，再学 Qt API。概念（TCP、端口、粘包）是通用的，Qt 只是更友好的实现工具。

qt-doc · Qt 智能文档 Skill

Tue, 13 Oct 2026 00:00:00 +0000

不要死记硬背 Qt 类名，告诉它你想干什么。

一个为 opencode 设计的 Qt 领域智能体 Skill：你只需要用中文描述需求（“查一下线程怎么用”），它会自动映射为 QThread，抓取官方文档，并返回小白能看懂的核心 API 总结。

这不是搜索引擎，这是一个懂 Qt 的领域智能体。

✨ 它能做什么

能力	说明	示例
意图感知	中文概念自动映射为 Qt 类名	“线程” → `QThread`，“画形状” → `QPainterPath`
继承链展开	自动递归抓取父类文档	查 `QTcpSocket` 返回整个 `QAbstractSocket→QIODevice→QObject` 族，2 个 API → 216 个
来源标注	每个 API 标注来自哪个类	`connectToHost`（来自 `QAbstractSocket`）
小白化总结	官方文档降维成通俗解释	构造函数 / 最常用函数 / 关键信号 / 示例 / 注意事项
三级数据源	在线 → 本地离线文档 → JSON 缓存	断网可用，二次查询秒回
会话隔离	显式开启专家模式，不误触发	未开启时零劫持 Web/Java 等非 Qt 问题

🚀 快速开始

环境要求

Python 3.10+
依赖：requests、beautifulsoup4
opencode（可选用任意支持 Skill 的 Agent 运行器）

安装

git clone <your-repo-url> qt-doc
cd qt-doc
pip install -r requirements.txt
# 安装 skill 到 opencode 全局（可选）
cp -r qt-doc ~/.config/opencode/skills/

使用

重启 opencode 后，在会话中：

qt-doc（Qt 智能文档）

Tue, 13 Oct 2026 00:00:00 +0000

仅当用户显式要求开启 Qt 专家模式时触发，如说"开启Qt专家模式"、“进入Qt专家模式”、 “Qt专家模式"等。

一旦触发，本会话进入 Qt 专家模式，直到会话结束：

之后该会话内的所有 Qt/C++ 问题都用本 skill 流程回答（映射类名→抓文档→小白化总结）。
会话保持生效：通过 /sessions 恢复该对话，专家模式依然生效。
新开对话默认不加载本 skill，需再次显式开启——实现会话级隔离。
在专家模式下，非 Qt 的通用编程问题（如 Java/Web）正常回答，不套用 Qt 文档流程。

流程

把用户描述映射为 Qt 类名（Q 开头）。
- 先查本 skill 目录下的 mapping.json 精确匹配。
- 未命中则凭 Qt 领域知识推断（如"画形状”→QPainterPath）。
- 无法确定时询问用户。
调用抓取脚本（可传多个类名，一次抓取）：
- 优先使用环境变量 QT_FETCH_CMD 指向脚本（如 python /path/to/qt_fetch.py）。
- 未设置时，用当前仓库内脚本：python <repo>/qt_fetch.py <类名1> <类名2>...。
- 示例：python ../qt_fetch.py QThread QTimer
读取 stdout JSON。若 errors 非空，说明该类未找到，提示用户检查拼写或模块。
基于 JSON 的 title/brief/apis 做小白化总结。

输出规范（中文，开头带 [qt-doc]）

这是什么：一句话说明该类用途。
构造函数：核心 1-2 个。
最常用函数：数量视类而定——核心常用类 5-8 个，简单类 3-4 个。
关键信号：1 个 + 触发时机（有信号时）。
示例代码：简短 5-8 行。
⚠️ 注意：继承或使用要点。

继承链

查询结果含 inheritance_chain（从派生到基类）与每个 API 的 inheritsFrom 来源。若某类 API 很少（如 QTcpSocket），说明它继承自父类，常用函数多在父类文档中—— 总结时应说明函数来自哪个父类（如 connectToHost 来自 QAbstractSocket）。

Qt5 信号槽重载与 explicit 关键字详解

Tue, 13 Oct 2026 00:00:00 +0000

适用版本：Qt 5.x / C++14+ 更新日期：2026-07-29

一、信号与槽函数重载（Overload）

在 Qt5 中，信号和槽函数发生重载是非常常见的场景，也是最容易引起编译错误或运行时行为不符合预期的地方。

由于 Qt5 使用 &ClassName::functionName 的新式语法，当遇到重载时，编译器无法自动推断你要使用哪一个具体的函数指针，因此必须进行强制类型转换或使用 Lambda 表达式来消除歧义。

场景假设

假设有一个类，里面定义了两个重载的普通成员函数（在 Qt5 中都可以当槽）：

class Receiver : public QObject
{
 Q_OBJECT
public:
 // 槽函数 1：无参
 void handleUpdate() {
 qDebug() << "无参槽被触发";
 }

 // 槽函数 2：带一个 int 参数
 void handleUpdate(int value) {
 qDebug() << "带参槽被触发，值为" << value;
 }
};

现在有一个信号想要连接到这个槽，有以下几种方案：

QTabWidget 与 QStackedWidget 的区别及常用方式

Tue, 13 Oct 2026 00:00:00 +0000

一、概述

QTabWidget 和 QStackedWidget 都是 Qt 中用于管理多页面切换的控件，但它们的设计定位和使用场景有显著区别。

特性	QTabWidget	QStackedWidget
内置导航	自带标签栏（Tab Bar）	无内置导航
页面切换方式	点击标签切换	需通过代码 `setCurrentIndex()` 切换
独立性	独立控件，开箱即用	需配合其他控件（如 QListWidget）使用
灵活性	固定标签栏样式	可自定义任意切换方式
适用场景	设置对话框、分类浏览	向导流程、无标签界面

二、QTabWidget — 自带标签栏的多页容器

2.1 特点

顶部（或底部/左侧/右侧）自带 QTabBar
每个 Tab 对应一个页面（QWidget 子类）
点击 Tab 自动切换页面，无需额外代码

2.2 常用方式

// 创建 TabWidget
QTabWidget *tabWidget = new QTabWidget(this);

// 创建页面
QWidget *page1 = new QWidget();
QWidget *page2 = new QWidget();

// 添加页面（传入 widget 和标题）
tabWidget->addTab(page1, "基本设置");
tabWidget->addTab(page2, "高级设置");

// 设置当前页
tabWidget->setCurrentIndex(0);

// 常用设置
tabWidget->setTabPosition(QTabWidget::North); // 标签位置
tabWidget->setTabShape(QTabWidget::Rounded); // 标签形状
tabWidget->setMovable(true);

// 信号与槽：标签切换
connect(tabWidget, &QTabWidget::currentChanged, [](int index) {
 qDebug() << "切换到第" << index << "页";
});

三、QStackedWidget — 无内置导航的页面堆栈

3.1 特点

不提供任何导航控件，只负责管理页面
一次只显示一个页面（当前页）
必须通过代码或其他控件控制切换

3.2 常用方式

// 创建 StackedWidget
QStackedWidget *stackedWidget = new QStackedWidget(this);

// 创建页面
QWidget *page1 = new QWidget();
QWidget *page2 = new QWidget();
QWidget *page3 = new QWidget();

// 添加页面（返回 index）
int idx1 = stackedWidget->addWidget(page1);
int idx2 = stackedWidget->addWidget(page2);
int idx3 = stackedWidget->addWidget(page3);

// 切换页面
stackedWidget->setCurrentIndex(1); // 按索引切换
stackedWidget->setCurrentWidget(page3); // 按指针切换

// 获取当前页面
int currentIdx = stackedWidget->currentIndex();

3.3 配合 QListWidget 实现导航

// 左侧列表 + 右侧堆栈的经典布局
QListWidget *list = new QListWidget();
list->addItem("基本设置");
list->addItem("高级设置");
list->addItem("关于");

QStackedWidget *stack = new QStackedWidget();
stack->addWidget(new BasicSettingsPage());
stack->addWidget(new AdvancedSettingsPage());
stack->addWidget(new AboutPage());

// 连接信号
connect(list, &QListWidget::currentRowChanged,
 stack, &QStackedWidget::setCurrentIndex);

3.4 配合 QPushButton 实现向导流程

// 上一步 / 下一步 向导
connect(btnNext, &QPushButton::clicked, [=]() {
 int next = stack->currentIndex() + 1;
 if (next < stack->count()) {
 stack->setCurrentIndex(next);
 }
});

connect(btnPrev, &QPushButton::clicked, [=]() {
 int prev = stack->currentIndex() - 1;
 if (prev >= 0) {
 stack->setCurrentIndex(prev);
 }
});

四、核心区别总结

对比维度	QTabWidget	QStackedWidget
内置 Tab 栏	有	无
实现代码量	少（开箱即用）	多（需自行实现导航）
切换方式	点击 Tab	`setCurrentIndex()` / `setCurrentWidget()`
自定义导航	受限（可隐藏 Tab 栏）	完全灵活
典型场景	偏好设置、分类浏览	安装向导、多步表单
灵活性	低（样式固定）	高（完全可控）

如何选择？

需要标准标签切换 → QTabWidget（简单快速）
需要自定义切换方式 → QStackedWidget（如列表导航、按钮翻页）
需要向导/步骤流程 → QStackedWidget（搭配按钮更自然）
既有标签又想自定义 → 用 QTabWidget 隐藏 TabBar + 代码控制切换

五、完整示例：左侧列表 + 右侧堆栈

#include <QApplication>
#include <QHBoxLayout>
#include <QListWidget>
#include <QStackedWidget>
#include <QLabel>

int main(int argc, char *argv[]) {
 QApplication app(argc, argv);

 QWidget window;
 QHBoxLayout *layout = new QHBoxLayout(&window);

 // 左侧导航
 QListWidget *list = new QListWidget();
 list->addItem("页面一");
 list->addItem("页面二");
 list->addItem("页面三");
 list->setFixedWidth(120);

 // 右侧页面
 QStackedWidget *stack = new QStackedWidget();
 stack->addWidget(new QLabel("这是页面一的内容"));
 stack->addWidget(new QLabel("这是页面二的内容"));
 stack->addWidget(new QLabel("这是页面三的内容"));

 layout->addWidget(list);
 layout->addWidget(stack, 1);

 connect(list, &QListWidget::currentRowChanged,
 stack, &QStackedWidget::setCurrentIndex);

 window.resize(600, 400);
 window.show();
 return app.exec();
}

QWidget 深入详解

Tue, 13 Oct 2026 00:00:00 +0000

1. 什么是 QWidget

QWidget 是 Qt 框架中所有用户界面对象的基类。它既是"控件"（widget），也是"窗口"（window）。在 Qt 的世界里，几乎所有可见元素都是 QWidget——按钮、标签、输入框、对话框，乃至整个应用程序的主窗口。

核心要点：QWidget 是一个"空白的矩形区域"，它知道如何绘制自己、如何处理鼠标键盘事件、如何管理子控件。你可以在它之上构建任意复杂的 UI。

核心职责

职责	说明
窗口管理	最小化、最大化、关闭、标题栏
绘制	通过 `paintEvent` 自绘外观
事件处理	鼠标、键盘、触控、拖放等
子控件管理	添加、删除、查找子控件
布局管理	与 QLayout 协作自动排列子控件
样式设置	通过 QSS 或 QPalette 定制外观

2. QWidget 的继承体系

QObject
└── QPaintDevice
└── QWidget ← 本文主角
├── QFrame
│ ├── QLabel
│ ├── QAbstractScrollArea
│ └── ...
├── QAbstractButton
│ ├── QPushButton
│ ├── QCheckBox
│ ├── QRadioButton
│ └── ...
├── QComboBox
├── QLineEdit
├── QSlider
├── QSpinBox
├── QDialog
├── QMainWindow
└── ...

QObject：提供了信号槽机制、对象树管理、事件过滤器等基础设施。
QPaintDevice：声明了"可以被绘制"的能力，提供了绘制设备的抽象接口。
QWidget：将两者结合，成为一个可交互、可绘制、可包含子对象的矩形区域。

3. 创建与基本使用

3.1 最简单的 QWidget

#include <QApplication>
#include <QWidget>

int main(int argc, char *argv[])
{
 QApplication app(argc, argv);

 QWidget w;
 w.setWindowTitle("Hello QWidget");
 w.resize(400, 300);
 w.show();

 return app.exec();
}

3.2 创建自定义 QWidget 子类

// MyWidget.h
#pragma once
#include <QWidget>
#include <QPainter>

class MyWidget : public QWidget
{
 Q_OBJECT // 启用信号槽、元对象特性
public:
 explicit MyWidget(QWidget *parent = nullptr);

protected:
 void paintEvent(QPaintEvent *event) override;
 void mousePressEvent(QMouseEvent *event) override;
};

// MyWidget.cpp
#include "MyWidget.h"
#include <QPainter>

MyWidget::MyWidget(QWidget *parent)
 : QWidget(parent)
{
 setMinimumSize(200, 150);
}

void MyWidget::paintEvent(QPaintEvent *)
{
 QPainter painter(this);
 painter.setRenderHint(QPainter::Antialiasing);
 painter.setBrush(QColor(100, 150, 255));
 painter.drawRoundedRect(rect().adjusted(5, 5, -5, -5), 10, 10);
}

void MyWidget::mousePressEvent(QMouseEvent *event)
{
 // 点击时改变颜色
 Q_UNUSED(event);
 update();
}

3.3 对象树与父子关系

QWidget 的构造函数接受一个 parent 参数：

select 多路复用

Tue, 13 Oct 2026 00:00:00 +0000

一个 goroutine 同时监听多个 channel 的「事件循环」：C++/epoll 监听多个 fd 的那个心智模型，Go 把它内建成了 select 语句

一、简述

select 是 Go 语法层面的多路复用（multiplexing）原语：它让一个 goroutine 同时等待多个 channel 上的收发操作，只要其中一个就绪，就走对应的分支。

对于 C++ 开发者，最贴切的类比是 Linux epoll / poll：你不想为每个 socket 各开一个线程去阻塞读，而是用一个线程同时监听一堆 fd，哪个有事件处理哪个。select 就是「 goroutine 版本的 epoll」——但它更进一步：它还能同时做非阻塞尝试（default）、定时超时（time.After）、动态禁用分支（nil channel）。

核心要点：select 是「组合 channel 为复杂同步逻辑」的胶水。没有 select，一个 goroutine 只能死等一个 channel；有了 select，你才能写超时、写取消、写事件循环、写多路汇流。

二、C++ 对照速查表

概念	C++	Go	关键差异
多路监听	`epoll_wait(fds, ...)` / `poll()`	`select { case <-ch1: ... }`	Go 是对 channel 通道复用，C++ 是对 fd 复用
同时等两个事件	一个线程一个 fd 各睡一觉 / epoll	一个 goroutine 同时等多个 case	`select` 内建，代码直白得多
随机公平选择	epoll 按就绪顺序返回	多 case 就绪时随机选一个	Go 保证公平：随机而非先后
非阻塞尝试	`poll(fd, timeout=0)`	`select { case ...: default: }`	`default` = 都不就绪立即走
超时等待	`epoll_wait` 的 timeout 参数	`select` + `time.After(1s)`	超时是普通 channel，不是特殊机制
收发都监听	读 / 写事件分别注册	一个 select 里既有发送又有接收 case	语法上收发对称
监听无限器	服务端 accept 线程循环	`for { select { ... } }`	事件循环惯用法
特定事件暂时屏蔽	取消注册 fd	case 的 channel 置 nil → 永久阻塞	nil channel 妙用

三、逐主题详解

3.1 select 基本语法

package main

import (
 "fmt"
 "time"
)

func main() {
 ch1 := make(chan string)
 ch2 := make(chan string)

 // 两个 goroutine 各自往不同 channel 发
 go func() { time.Sleep(100 * time.Millisecond); ch1 <- "来自 ch1" }()
 go func() { time.Sleep(300 * time.Millisecond); ch2 <- "来自 ch2" }()

 // select 会阻塞，直到某个 case 就绪
 select {
 case msg := <-ch1:
 fmt.Println("收到:", msg) // 大概率先到 ch1（100ms 更快）
 case msg := <-ch2:
 fmt.Println("收到:", msg)
 }
}

要点：

sync 包（WaitGroup / Mutex / Once）

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 std::thread::join、std::mutex、std::once_flag，Go 用 sync 包给了一套轻量且更安全的等价物

一、简述

sync 包是 Go 标准库的同步原语仓库，核心成员：

类型	用途	C++ 对应
`sync.WaitGroup`	等一批 goroutine 全部结束	`std::thread::join`（一次等多个）
`sync.Mutex`	互斥锁	`std::mutex`
`sync.RWMutex`	读写锁	`std::shared_mutex`
`sync.Once`	只执行一次（懒加载 / 单例）	`std::once_flag` + `std::call_once`
`sync.Map`	并发安全的 map（特化场景）	手写 lock + `std::map` / 无直接对应
`sync.Cond`	条件变量	`std::condition_variable`

核心要点：Go 的哲学是「尽量用 channel」，但同步原语（锁 / 分组等待 / 只跑一次）仍然有明确位置。与 C++ 的锁相比，Go 的锁不可拷贝、有 defer 配合的极简用法、内置检测工具，心智负担小得多。本笔记重点讲 WaitGroup、Mutex / RWMutex、Once，并简述 errgroup。

二、C++ 对照速查表

概念	C++	Go	关键差异
等待线程结束	`t.join()`（单个）	`wg := sync.WaitGroup{}; wg.Add(1); defer wg.Done(); wg.Wait()`	WaitGroup 一次等一批，Add 要提前
互斥锁	`std::mutex m; m.lock(); m.unlock();`	`var mu sync.Mutex; mu.Lock(); defer mu.Unlock()`	Go 惯例用 `defer` 解锁，防漏
锁唯一性	lock 传递没意义	结构体字段还是值？拷贝锁 = 复制已锁状态 → 编译常见错	Go 锁内含 `noCopy`，拷贝会被提示
只初始化一次	`std::once_flag` + `std::call_once`	`var once sync.Once; once.Do(func(){...})`	Go 写进一个 `Do`，天然幂等
读写锁	`std::shared_mutex`（C++17）	`sync.RWMutex` + `RLock()/RUnlock()`	读读并发、写写互斥、写独占
可重入	`std::recursive_mutex` 才行	Mutex 不可重入，同 goroutine 再锁 = 自锁死	Go 明确拒绝重入，倒逼更好的设计
条件变量	`std::condition_variable` + predicate 循环	`sync.Cond`（少见）或直接 channel	Go 社区倾向 channel 代替 cond
分组错误传播	手写 `std::future` 收集异常	`errgroup.Group`（`golang.org/x/sync`）	Go 有现成库，等全部且带首个错误

三、逐主题详解

3.1 sync.WaitGroup：等一批 goroutine

package main

import (
 "fmt"
 "sync"
 "time"
)

func worker(id int, wg *sync.WaitGroup) {
 defer wg.Done() // 结束前把计数器减 1（defer 保证即使中途 panic 也会减，避免死锁）
 fmt.Printf("worker %d 开始\n", id)
 time.Sleep(100 * time.Millisecond) // 模拟干活
 fmt.Printf("worker %d 结束\n", id)
}

func main() {
 var wg sync.WaitGroup

 for i := 1; i <= 3; i++ {
 wg.Add(1) // ⚠️ Add 必须在 go 之前！计数器先 +1
 go worker(i, &wg) // 注意传指针：WaitGroup 内部要改计数
 }

 wg.Wait() // 阻塞直到所有 Done，相当于「等这一批全部 join」
 fmt.Println("所有 worker 都结束了")
}

WaitGroup 规则：

unsafe 与 cgo 互操作

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 reinterpret_cast + extern "C" 在 Go 里被装进了两个官方包：unsafe（打破类型/GC 规则）和 cgo（跨语言边界）

一、简述

Go 追求内存安全，但现实里有三类需求绕不开"不安全"：解析二进制布局、优化热路径、调用 C 库。Go 给的两把钥匙：unsafe 包的 unsafe.Pointer 允许你绕过类型系统（但仍受 GC 语义约束），cgo 允许你直接调用 C 函数（import "C" + //export 双向互操作）。本章把两者的语义、内存规则、坑、风险一次性讲透——很多线上故障就是从"玩 unsafe 没算清 GC"或"cgo 调用频繁导致线程放大"开始的。

核心要点：unsafe.Pointer 像"元指针"，可被 GC 追踪；uintptr 只是整数，GC 不追踪——所以不允许"把指针存成 uintptr 长期持有"。cgo 让你调 C，但每次调用都伴随 goroutine 栈切换与可能的线程膨胀，且 C.CString 分配的内存必须自己 C.free。CGO_ENABLED=0 是纯静态交叉编译的开关，代价是放弃 cgo。

二、C++ 对照速查表

概念	C++	Go	关键差异
无类型转换	`reinterpret_cast<T*>`	`unsafe.Pointer` 转换	Go 的三步规则更受限，且有 GC 约束
类型大小	`sizeof(T)`	`unsafe.Sizeof(x)`	一样，但 Go 的 `Sizeof` 返回 `uintptr`
对齐要求	`alignof(T)`	`unsafe.Alignof(x)`	语义相同
成员偏移	`offsetof`	`unsafe.Offsetof(s.F)`	Go 对嵌套/嵌入结构有规则限制
指针算术	`p + n`（任意）	`uintptr(p) + n` 转回	Go 用 uintptr 防 GC 丢对象（坑）
跨语言符号	`extern "C"`	`//export` / 声明	Go 还自动处理了 C 的 ABI 与参数传值
头文件	`#include`	`// #include <...>` 注释块 + `import "C"`	cgo 注释必须紧跟 import
C 字符串生命周期	`std::string`/手管 char*	`C.CString` → `C.free`	Go 里 C 内存在你的掌控（GC 不管）
跨语言回调	函数指针显式传	`//export` 导出给 C	回调时 cgo 会切换刻意绑的线程
交叉编译	工具链编译 C 代码	`CGO_ENABLED=0` 纯 Go	纯 Go 无 cgo 才能一路交叉到底

三、逐主题详解

3.1 `unsafe` 包三件套：Sizeof / Alignof / Offsetof

package main

import (
 "fmt"
 "unsafe"
)

type Header struct {
 Magic uint16 // 2 字节
 Flags byte // 1 字节
 Body uint32 // 4 字节（需要对齐）
}

func main() {
 h := Header{}
 fmt.Println("Sizeof:", unsafe.Sizeof(h)) // 8（不是 2+1+4=7，有 padding）
 fmt.Println("Alignof:", unsafe.Alignof(h)) // 4（最大成员对齐）
 fmt.Println("Offsetof Magic:", unsafe.Offsetof(h.Magic)) // 0
 fmt.Println("Offsetof Flags:", unsafe.Offsetof(h.Flags)) // 2
 fmt.Println("Offsetof Body:", unsafe.Offsetof(h.Body)) // 4（3 处 padding 1 字节填在中间）
}

Offsetof 要求字段是可寻址的（s.F 形式，不能是未导出字段）。
这些原语从 1.0 至今，官方 docs 明确：unsafe 不提供兼容性承诺，后续版本可能变——但在已知版本内是可靠的。
C++ 对照：sizeof/alignof/offsetof 早已内建，返回 size_t；Go 返回 uintptr。布局算法的直觉（对齐、padding）两者完全一致——你可以把你对 C++ 结构体内存布局的知识直接迁移过来。

3.2 `unsafe.Pointer` 与 `uintptr` 的区别（本章最核心）

特性	`unsafe.Pointer`	`uintptr`
本质	指针（与 `*T` 同族）	整数（地址的编号）
GC 追踪	✅ 是（对象可达性参与）	❌ 不是（就是个数字）
可做算术	❌ 不能直接 `+n`	✅ 可以
可长期保存	✅（Go 1.17+ 合法）	❌ 存久了=可能悬垂
转换	`T` ↔ `unsafe.Pointer` ↔ `U`	`uintptr(unsafe.Pointer(...))`

p := unsafe.Pointer(&x) // &x 是 *int → unsafe.Pointer（合法）
up := uintptr(p) // 转成整数（此时"失去指针身份"）
_ = up
// ⚠️ 一旦 p 指向的对象被 GC 移动/回收，up 就是"悬垂整数"
// Go 的 GC 不移动对象，但会回收；up 长期保存=访问已释放内存（未定义行为）

官方三步规则（Go 文档的『Conversion』/『Restrictions』，一共 7 条），核心是三种合法模式：

VS 向导 vs CMake 手建工程：一次取舍记录

Tue, 13 Oct 2026 00:00:00 +0000

新建 C++ 项目时，用 VS2022 项目向导，还是手建目录 + CMake？核心结论：向导是「快」，CMake 手建是「稳」；长期维护的 Boost + OpenCV 项目走 CMake 手建路线。

一、「完全不利用 VS 向导」指什么

VS 新建项目时，向导会自动生成：

目录结构
.vcxproj / .sln
一些默认代码
默认的编译配置

不用向导，就是自己手建目录、手写 CMakeLists.txt、用 VS 的「打开文件夹」模式加载。

二、CMake 手建的好处

#	好处	说明
1	结构清晰、可控	向导生成的项目，目录和配置是向导定的；手建时 `src/`、`include/`、`resources/`、`tests/` 怎么分，自己说了算
2	跨平台	`CMakeLists.txt` 是跨平台的：同一个项目，Windows 用 MSVC，WSL 用 GCC，不用改任何东西；向导生成的 `.vcxproj` 只能在 VS 里用
3	依赖管理统一	Boost、OpenCV 全走 `find_package`，环境变量一配，所有项目通用；向导的项目要手动一个个加 include、lib 路径
4	不污染仓库	`.vcxproj`、`.sln`、`.vs/`、`out/` 都是本地文件，不进 Git；CMake 项目只需提交 `CMakeLists.txt` 和源码，干净
5	和工业界一致	大多数 C++ 开源项目、跨平台项目都用 CMake；养成这个习惯，以后参与别人的项目、或自己发布项目，都顺
6	配置一次、项目复用	环境变量和 `CMakeLists.txt` 模板定好后，新建项目就是复制模板、改项目名、加源文件。增量配置，不是每次从零配

三、CMake 手建的代价

初期配置复杂。第一次要理解：CMakeLists.txt 的语法、find_package 怎么找库、环境变量怎么设、CMakePresets.json 的格式。这些概念对新手是门槛。
VS 集成不如原生项目「顺滑」。向导项目是 VS 原生支持，调试、IntelliSense 开箱即用；CMake 项目通过「打开文件夹」或「CMake 项目」模式支持，功能也全，但偶尔会遇到配置识别问题。
调试和 IDE 功能偶有摩擦。断点、监视窗口、调用栈这些都没问题；但某些 VS 特有的功能（比如某些项目属性页面），在 CMake 项目里没有对应入口。
学习曲线。要同时学 CMake、学 Boost/OpenCV 的 CMake 配置。一次性投入大，但长期收益高。

四、取舍小结

整体体验是：结构清晰，配置相对复杂；不过做项目时配置一次，后续只是增量配置。

VS2022 打开 CMake 项目的调试说明：断点与 launch.vs.json

Tue, 13 Oct 2026 00:00:00 +0000

手建的 CMake 项目在 VS2022「打开文件夹」模式下的打开方式、自动生成的配置、断点调试与 launch.vs.json。核心结论：CMake 项目的调试体验与向导项目基本一致，唯一多出的一步是手动选启动目标。

一、怎么用 VS 打开手建的 CMake 项目

步骤：

VS2022 → 文件 → 打开 → 文件夹。
选项目根目录，比如 <项目根目录>\MyProject。
VS 自动识别 CMakeLists.txt，切换到 CMake 项目模式。

VS 会自动做的事：

读 CMakeLists.txt，配置 CMake。
在项目根目录生成 .vs/，存 VS 自己的状态。
在 out/build/ 下生成构建产物。
底部状态栏出现 配置选择器（Debug/Release），和 CMake 目标选择器。

和向导项目一样，VS 该自动生成的还是会生成。

二、VS 自动生成的配置有哪些

和向导项目时一样：

.vs/：VS 的工作状态、索引、窗口布局。不提交 Git。
out/：CMake 构建产物。不提交 Git。
CMakeUserPresets.json：如果在 VS 里改过预设，它可能生成这个。不提交 Git。

这些不影响项目结构本身，只是 VS 的本地缓存，删了能重建。

三、断点怎么用

CMake 项目的断点和向导项目完全一样。

基本流程

在代码行号左边点一下，出现红点，就是断点。
按 F5 启动调试（不是 Ctrl+F5，Ctrl+F5 是不调试直接运行）。
程序运行到断点处停下，VS 自动切换到调试界面。
底部出现调试工具栏：继续、单步跳过、单步进入、跳出。
左侧或底部窗口：局部变量、监视、调用栈、断点列表。

常用快捷键

操作	快捷键
启动调试	`F5`
停止调试	`Shift + F5`
单步跳过（不进入函数）	`F10`
单步进入（进入函数）	`F11`
跳出当前函数	`Shift + F11`
继续运行	`F5`
切换断点	`F9`
条件断点	右键断点 → 条件

CMake 项目特有的注意点

1. 启动目标

Web 框架 Gin / Echo

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 Crow / Drogon 到 Go：Gin 是什么、何时该用它，以及它替你省下的那些 net/http 样板代码

一、简述

上一篇我们把 net/http 摸了一遍——纯标准库完全能写服务，但路由到参数、JSON 绑定校验、中间件这些「每个项目都要重复一遍」的活，写得多了就烦。Gin 和 Echo 是 Go 生态里最主流的两个 Web 框架，它们把「路由分组 + 参数绑定 + 校验 + 中间件」整合成统一 API。Gin 以高性能（基于 radix tree 的路由器）和极简 API 出名，Echo 结构更规整、前后端感触更「框架味」。

核心要点：框架不改变 Go 的 Web 本质——底层还是 http.Handler；Gin/Echo 只是给你一个更顺手的 c *gin.Context / e echo.Context。「参数绑定 + binding tag 校验」是 C++ 框架（如 Drogon）很难优雅做到的事，Go 用结构体标签声明式解决，这是最大的体验提升点。

二、C++ 对照速查表

概念	C++	Go	关键差异
Web 框架	Crow / Drogon / cpp-httplib	Gin / Echo	Gin 性能强、Echo 规整
路由注册	`CROW_ROUTE(app, "/x")`	`r.GET("/x", fn)`	链式+分组，表达力更强
路径参数	`CROW_ROUTE(app,"/<int>")` 回调参数	`c.Param("id")`	参数进 Handler 上下文
路由分组	手动前缀	`r.Group("/api")`	组内共享中间件/前缀
JSON 返回	`app.route(...).post(...)` 手动拼	`c.JSON(200, obj)`	一行返回+自动 Content-Type
参数绑定	手写解析字段	`c.ShouldBindJSON(&req)`	结构体 tags 声明式映射
参数校验	手写 if 判断	`binding:"required"`	tag 驱动，绑定即校验
中间件	手动包装 / 框架回调	`r.Use(mw)`	全局/组/路由三级粒度
panic 恢复	手动 try/catch	`gin.Recovery()` 内置	框架默认就带

三、逐主题详解

3.1 Gin 起步 —— 一个能跑的 Hello

安装并写最小服务：

Windows 上 Boost + OpenCV + CMake 的环境配置方案：只配两件事

Tue, 13 Oct 2026 00:00:00 +0000

从零配置的一套通用方案：环境变量 + CMakePresets.json。一次配好，所有项目通用。Windows 端只配 Boost + OpenCV，不配 Qt（Qt 开发放在 Linux 端）。

文中 <OpenCV安装目录>、<Boost根目录>、<项目根目录> 为占位符，替换成本机实际目录即可。

一、环境变量（系统变量）

在 Windows「系统属性 → 环境变量」里，系统变量新建：

变量名	值	作用
`OpenCV_DIR`	`<OpenCV安装目录>\build\x64\vc16\lib`	OpenCV 的 `Config.cmake` 所在目录
`BOOST_ROOT`	`<Boost根目录>`	Boost 根目录

PATH 追加（运行时找 dll）：

<OpenCV安装目录>\build\x64\vc16\bin

Boost 不用加 PATH，静态库，运行时不需要 dll。

二、每个库的配置细节

OpenCV

关键文件（示例路径）：

<OpenCV安装目录>\build\x64\vc16\lib\OpenCVConfig.cmake
<OpenCV安装目录>\build\x64\vc16\lib\opencv_world4100.lib
<OpenCV安装目录>\build\x64\vc16\lib\opencv_world4100d.lib

变量：

OpenCV_DIR = <OpenCV安装目录>\build\x64\vc16\lib

CMake 里：

find_package(OpenCV REQUIRED)
target_include_directories(main PRIVATE ${OpenCV_INCLUDE_DIRS})
target_link_libraries(main PRIVATE ${OpenCV_LIBS})

Boost

关键文件（示例路径）：

<Boost根目录>\stage\lib\cmake\Boost-1.81.0\BoostConfig.cmake
<Boost根目录>\stage\lib\libboost_filesystem-vc143-mt-x64-1_81.lib
<Boost根目录>\stage\lib\libboost_filesystem-vc143-mt-gd-x64-1_81.lib

变量：

BOOST_ROOT = <Boost根目录>

CMake 里：

set(Boost_NO_SYSTEM_PATHS ON)
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_MULTITHREADED ON)

find_package(Boost 1.81 REQUIRED COMPONENTS filesystem system thread)
target_link_libraries(main PRIVATE Boost::filesystem Boost::system Boost::thread)

注意：Boost 大部分是 header-only，find_package 只对需要编译的库（filesystem、system、thread 等）起作用。header-only 的库直接 #include 就行，CMake 里不用 find_package。

包与导入

Tue, 13 Oct 2026 00:00:00 +0000

Go 的"包"是组织代码的唯一单元。一个目录就是一个包，没有头文件，没有 .cpp/.h 分离。理解包的规则，是读懂 Go 项目结构的第一步。

1. 核心概念速览

package 声明

每个 .go 文件的第一行必须是 package 声明，且同一目录下所有文件必须声明相同的包名。

// 文件: mathutil/add.go
package mathutil

// 同目录的 subtract.go 也必须是:
// package mathutil

func Add(a, b int) int { return a + b }

package main — 程序入口

package main 是特殊约定，表示可执行程序的入口，不是库包。Go 没有独立的入口函数声明——入口就是 package main 里的 func main()。

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go!")
}

C++ 对照: package main ≈ 包含 int main() 的那个编译单元。

2. C++ 对照速查表

Go 概念	C++ 对应	差异说明
`package`	`namespace` + `#include`	一个 package 同时提供命名空间和导入功能，不需要头文件
`import`	`#include`	import 加载的是编译好的包，不是文本包含
首字母大写 = 导出	`public` / `protected`	基于命名规则，不是关键字；小写 = 包内可见
首字母小写 = 私有	`private`	同上，没有 `private` 关键字
一个目录一个包	一个模块/目录	同目录必须同 package，不可混装
`init()`	全局变量的构造函数	更可靠，保证在 `main()` 之前执行
`import . "fmt"`	`using namespace std;`	同样不推荐，污染命名空间
循环导入	循环 `#include`	两者都是编译错误
`internal/`	C++ 无直接对应	类似 `friend` 的简化版，限制子包的可见性
`go.mod` 依赖管理	CMake / Conan / vcpkg	Go 原生支持，无需第三方工具

3. 导入语法

单行导入

package main

import "fmt"

func main() {
 fmt.Println("单行导入")
}

分组导入（推荐）

package main

import (
 "fmt"
 "os"
 "strings" // 标准库放一组
)

func main() {
 fmt.Println(strings.Join(os.Args[1:], " "))
}

C++ 对照: Go 的 import 会自动加载包内所有导出符号，不需要逐个 include 头文件。

包与模块

Tue, 13 Oct 2026 00:00:00 +0000

Go 的包组织、可见性规则与模块系统深入

一、包（Package）基础

1.1 什么是包

// 每个 Go 文件都必须声明自己属于哪个包
package main // main 包是可执行程序的入口

// 同一目录下的所有 .go 文件必须属于同一个包
// 例外：_test.go 文件可以声明 _test 包（用于黑盒测试）

1.2 包的命名规则

// 包名：小写单词，不要下划线或驼峰
package mypackage // ✅
package my_package // ❌
package MyPackage // ❌

// 目录名 = 包名
// src/
// └── utils/ // 目录名 utils
// ├── string.go // package utils
// └── math.go // package utils

1.3 main 包的特殊性

// main 包 + main() 函数 = 可执行程序
package main

import "fmt"

func main() {
 fmt.Println("Hello!")
}

二、导入（Import）

2.1 基本导入

import "fmt" // 标准库
import "github.com/gin-gonic/gin" // 第三方包

// 批量导入
import (
 "fmt"
 "os"
 "strings"
)

2.2 导入别名

// 解决包名冲突
import (
 "fmt"
 myfmt "github.com/other/fmt" // 别名
)

2.3 点导入与下划线导入

// 点导入：将包的导出标识符引入当前命名空间
import . "fmt"
Println("Hello") // 不需要 fmt.Println

// ⚠️ 不推荐使用——降低代码可读性

// 下划线导入：只执行包的 init() 函数
import _ "github.com/go-sql-driver/mysql" // 注册 MySQL 驱动
// 不使用包中的任何标识符，只是让 init() 被调用

三、可见性规则（大小写）

3.1 导出规则

Go 没有 public/private 关键字，通过首字母大小写控制可见性：

变量、常量与类型

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 到 Go：变量声明、常量、基本类型与类型系统的核心差异

一、简述

Go 的类型系统比 C++ 更简单、更严格：没有隐式类型转换，没有函数重载，没有模板/泛型（Go 1.18 后有泛型但用法不同）。这看似"退步"，实际上大幅降低了代码的心智负担——编译器替你做了大量约束。

对于 C++ 开发者，最需要适应的三个变化：

所有未使用的变量都会报错（unused variable）
类型转换必须显式（没有 int x = 3.14 这种事）
string 是值类型（赋值和传参都会拷贝，不像 std::string 有引用计数）

二、C++ 对照速查表

概念	C++	Go	备注
变量声明	`int x;`	`var x int`	Go 声明与赋值分离
类型推断	`auto x = 42;`	`x := 42`	`:=` = 声明 + 推断 + 赋值
常量	`const int X = 10;`	`const X = 10`	Go 常量不需要写类型
编译期常量	`constexpr int X = 10;`	`const X = 10`	Go 的 `const` 全部是编译期常量
枚举	`enum Color { RED, GREEN };`	`const ( RED = iota; GREEN )`	Go 用 `iota` 实现枚举
隐式转换	`double d = 42;`（合法）	不允许	Go 必须显式：`float64(42)`
字符串	`std::string s = "hi";`（引用语义）	`s := "hi"`（值类型）	Go string 赋值是拷贝
字符	`char c = 'A';`	`var c byte = 'A'` 或 `var c rune = 'A'`	Go 没有 `char` 类型
多变量声明	`int a, b;`	`var a, b int`	或 `a, b := 1, 2`
零值	未初始化（UB/随机值）	自动零值	Go 所有变量声明后都有零值
类型别名	`using MyInt = int;`	`type MyInt int`	Go 叫"类型定义"，不是别名
打印	`std::cout << x;`	`fmt.Println(x)`	Go 用 `fmt` 包格式化输出

三、变量声明

3.1 `var` 声明

package main

import "fmt"

func main() {
 // 基本语法：var 变量名 类型
 var name string // 声明但不赋值，零值为 ""
 var age int // 零值为 0
 var active bool // 零值为 false

 // 声明并赋值
 var score int = 100
 var lang string = "Go"

 // 类型推断：省略类型，编译器从右侧推断
 var version = 2 // 推断为 int
 var pi = 3.14 // 推断为 float64（Go 默认浮点类型）
 var greeting = "hello" // 推断为 string

 fmt.Println(name, age, active, score, lang, version, pi, greeting)
}

C++ 对照：

变量与类型

Tue, 13 Oct 2026 00:00:00 +0000

Go 的变量声明、基本类型与类型系统基础

一、变量声明

Go 是静态类型语言——变量的类型在编译时确定。

1.1 四种声明方式

// 1. var 显式声明（指定类型）
var name string = "Go"

// 2. var 显式声明（类型推断）
var name = "Go"

// 3. := 短变量声明（最常用，只能在函数内使用）
name := "Go"

// 4. var 批量声明
var (
 age int = 25
 height float64 = 175.5
 isGo bool = true
)

1.2 := 的限制

// ✅ 函数内部 — 可以用 :=
func main() {
 x := 10
 fmt.Println(x)
}

// ❌ 包级别 — 不能用 :=，必须用 var
var globalVar = "ok"
// globalVar := "fail" // 编译错误

1.3 零值

Go 中未赋值的变量自动初始化为零值（不是 undefined 或 null）：

标准库核心包：fmt / strings / os / io / time

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 iostream / string / fstream / chrono 到 Go 标准库核心包

一、简述

Go 标准库是"开箱即用"的典范——网络、JSON、加密、压缩、时间、文件全都在标准库里。本笔记聚焦日常开发最高频的 5 个包：fmt（格式化）、strings（字符串）、os（文件/环境）、io（读写抽象）、time（时间）。

核心要点：这些包配合 Go 的"接口即抽象"哲学（io.Reader / io.Writer），形成了统一的数据流处理模型——你写的函数只需要面向接口，就能处理文件、内存、网络任何来源。

二、C++ 对照速查表

概念	C++	Go	关键差异
格式化输出	`std::cout << x`	`fmt.Println(x)`	Go 内置格式动词
格式化字符串	`sprintf(buf, "%d", x)`	`fmt.Sprintf("%d", x)`	返回 string，无缓冲区
字符串操作	`std::string` / `<cstring>`	`strings` 包	函数式，无成员方法
字符串拼接	`s1 + s2`	`strings.Join` / `strings.Builder`	大量拼接用 Builder
文件读取	`std::ifstream`	`os.Open` + `io.ReadAll`	接口化
文件写入	`std::ofstream`	`os.WriteFile`	一键写整个文件
时间获取	`std::chrono::system_clock::now()`	`time.Now()`	返回 Time 结构体
休眠	`std::this_thread::sleep_for`	`time.Sleep`	用法相似
计时	`std::chrono::duration`	`time.Since(t)`	返回 Duration

三、fmt —— 格式化

3.1 输出函数

fmt.Print("a", "b") // 无换行、无空格: ab
fmt.Println("a", "b") // 空格分隔 + 换行: a b
fmt.Printf("%s %d", "go", 1) // 格式化: go 1

// 返回字符串版本
s := fmt.Sprintf("%s-%d", "v", 3) // "v-3"

3.2 常用格式动词

动词	含义	示例
`%v`	默认格式（任意类型）	`fmt.Printf("%v", 42)`
`%+v`	结构体带字段名	`fmt.Printf("%+v", p)` → `{Name:tom Age:18}`
`%#v`	Go 语法表示	`fmt.Printf("%#v", p)` → `main.Person{Name:"tom"}`
`%T`	类型	`fmt.Printf("%T", 42)` → `int`
`%d`	十进制整数	`42`
`%x`	十六进制	`2a`
`%f` / `%.2f`	浮点 / 保留两位	`3.14` / `3.14`
`%s`	字符串	`"hello"`
`%q`	带引号字符串	`"hello"`
`%t`	布尔	`true`
`%p`	指针地址	`0xc0000b2000`

3.3 对齐与宽度

fmt.Printf("%-10s|%10s\n", "left", "right")
// left | right

fmt.Printf("%05d\n", 42) // 00042（前导零）

四、strings —— 字符串处理

Go 的 string 是不可变值类型，所有操作都返回新字符串。

并发编程基础

Tue, 13 Oct 2026 00:00:00 +0000

Goroutine、Channel、Select——Go 并发的核心原语

一、Goroutine

1.1 什么是 Goroutine

Goroutine 是 Go 运行时管理的轻量级线程。创建成本极低（约 2KB 栈空间），可以轻松创建成千上万个。

// 启动一个 goroutine：在函数调用前加 go 关键字
go doSomething()
go func() {
 fmt.Println("running in goroutine")
}()

1.2 基本使用

package main

import (
 "fmt"
 "time"
)

func printNumbers() {
 for i := 1; i <= 5; i++ {
 time.Sleep(100 * time.Millisecond)
 fmt.Printf("number: %d\n", i)
 }
}

func printLetters() {
 for i := 'a'; i <= 'e'; i++ {
 time.Sleep(150 * time.Millisecond)
 fmt.Printf("letter: %c\n", i)
 }
}

func main() {
 go printNumbers() // 并发执行
 go printLetters() // 并发执行

 time.Sleep(2 * time.Second) // 等待 goroutine 完成
 fmt.Println("done")
}
// 输出交错出现：number: 1, letter: a, number: 2, letter: b...

1.3 主 Goroutine 与 WaitGroup

上面用 time.Sleep 等待是不可靠的。正确做法是用 sync.WaitGroup：

并发模式（worker pool / 扇入扇出 / pipeline）

Tue, 13 Oct 2026 00:00:00 +0000

C++ 里要自己造轮子的线程池、任务队列、流水线，Go 用 channel 组合出几种固定范式，一次学会受用终生

一、简述

「并发模式」不是语法，而是被反复验证有效的编排范式。Go 里它们几乎全由 channel + goroutine 组合而成：worker pool（工人池）、fan-out（扇出）、fan-in（扇入 / 汇聚）、pipeline（流水线）、限速器（rate limit）、错误传播。

对于 C++ 开发者，这些模式你多半见过、也手动实现过：

模式	C++ 里怎么做的	痛点
线程池	`std::thread` 数组 + `std::queue` 任务 + mutex 守卫	线程生命周期、任务派发、锁竞争都要自己管
扇出	把一个大任务拆 N 份发给 N 线程	怎么「等所有分片」+ 汇总
流水线	每个 stage 一个线程 + 队列 + condvar	关停时机难管
限速	令牌桶 / 手写信号量	又要造一个计数器 + 条件变量

Go 里这些平均不到 30 行，且语义全部显式可见。本笔记不讲抽象，直接给 6 个能 go run 的模板。

核心要点：所有模式都建立在「channel 即队列 + 同步」之上。模式 = 固定形状的 channel 拓扑 + 一组约定（谁 close、谁 range、谁 Wait）。

测试：单元、表格驱动、基准、覆盖率

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 GTest 到 Go testing 标准库：约定优于配置，表格驱动是 Go 的灵魂测试法

一、简述

Go 把测试框架内置为标准库 testing，零配置、约定驱动：文件以 _test.go 结尾，函数名 TestXxx(t *testing.T) 即被测对象。不需要 GTest 那样的宏和注册表，go test 一条命令跑全部测试。

C++ 开发者上手 GTest 要经历「链接 gtest、写 TEST 宏、配 CMake、起 runner」；Go 则是「建 _test.go、写 func TestXxx(t *testing.T)、go test」。**表格驱动测试（table-driven tests）**是 Go 社区最推崇的测试形态——本质是把断言与数据分离，让测试用例变成一张表。

核心要点：testing 包只给了「基础骨架」（t 的各种方法），断言与 mock 不内置——这是 Go 的极简哲学。但配合表格驱动 + 子测试 + 基准 + 覆盖率，能覆盖绝大多数项目需求。

二、C++ 对照速查表

概念	C++	Go	关键差异
测试框架	GoogleTest / Catch2（第三方）	`testing` 标准库	零依赖、零配置，`go test` 即跑
测试文件	`test_xxx.cpp`	`xxx_test.go`	命名约定即可被发现
测试用例	`TEST(Suite, Name)`	`func TestXxx(t *testing.T)`	编译期自动收集，无宏无注册
断言	`EXPECT_EQ` / `ASSERT_EQ`	`t.Errorf` / `t.Fatal`	Go 里就是普通方法调用
致命 vs 非致命	ASSERT（终止）vs EXPECT（继续）	`t.Fatal`（终止）vs `t.Errorf`（继续）	语义一一对应
子测试	SCOPED_TRACE 近似	`t.Run("name", ...)`	自带层级输出、可独立筛选运行
表格驱动	GTEST 参数化 P 复杂	切片 + for 循环	语言特性天然支持，无需框架
基准测试	Google Benchmark	`BenchmarkXxx(b *testing.B)` + `b.N`	benchmark 内建
覆盖率	`-fprofile-arcs` + gcov/lcov	`go test -cover`	一条命令带 HTML 输出
数据竞态检测	TSan（需编译期开启）	`go test -race`	运行时内建，跨平台

三、逐主题详解

3.1 单元测试最小形态

在 calc.go 旁边放 calc_test.go：

测试与工程实践

Tue, 13 Oct 2026 00:00:00 +0000

Go 的内置测试框架、代码规范与工程化实践

一、单元测试

1.1 测试文件命名

// 测试文件以 _test.go 结尾
math.go → math_test.go
user.go → user_test.go
utils/string.go → utils/string_test.go

1.2 基本测试函数

// math.go
package math

func Add(a, b int) int {
 return a + b
}

// math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
 result := Add(1, 2)
 if result != 3 {
 t.Errorf("Add(1, 2) = %d; want 3", result)
 }
}

// 运行测试
// go test ./...
// go test -v ./...（详细输出）

1.3 Table-Driven Tests（表驱动测试）

Go 社区最推崇的测试模式：

func TestAdd(t *testing.T) {
 tests := []struct {
 name string
 a, b int
 expected int
 }{
 {"positive numbers", 1, 2, 3},
 {"negative numbers", -1, -2, -3},
 {"zero", 0, 0, 0},
 {"mixed", -1, 1, 0},
 }

 for _, tt := range tests {
 t.Run(tt.name, func(t *testing.T) {
 result := Add(tt.a, tt.b)
 if result != tt.expected {
 t.Errorf("Add(%d, %d) = %d; want %d",
 tt.a, tt.b, result, tt.expected)
 }
 })
 }
}

// 运行特定子测试
// go test -run TestAdd/positive_numbers

1.4 测试辅助函数

// 断言辅助函数（Go 标准库没有内置 assert，但可以自己写）
func assertEqual(t *testing.T, got, want interface{}) {
 t.Helper() // 标记为辅助函数，错误信息显示调用者行号
 if got != want {
 t.Errorf("got %v, want %v", got, want)
 }
}

func TestAdd(t *testing.T) {
 assertEqual(t, Add(1, 2), 3)
}

t.Helper()：标记辅助函数，错误时显示调用方的行号而非辅助函数内部行号。

常用工具 gofmt/vet/doc/交叉编译

Tue, 13 Oct 2026 00:00:00 +0000

从 clang-format/clang-tidy/doxygen 到 Go 内建工具链：规范靠工具强制，而非风格文档

一、简述

Go 的工具链是「一个 go 命令 + 若干子命令」的整体。gofmt 统一代码格式、go vet 做静态检查、go doc 生成/查看文档、go build 配合环境变量实现交叉编译。与 C++ 需要 clang-format + clang-tidy + doxygen + 一堆脚本不同，Go 把规范内置——gofmt 的格式无人争论，因为唯一标准。

核心要点：gofmt 从 Go 项目诞生起就存在，go fmt 只是 go 工具链对它的子命令封装，两者格式化结果一致；真正的工程价值是让「风格讨论」从代码评审里消失——C++ 团队为空格和括号开过的会，在 Go 里不存在。

二、C++ 对照速查表

概念	C++	Go	关键差异
代码格式化	clang-format（需 .clang-format 配置）	`gofmt` / `go fmt`	零配置，官方唯一风格
静态检查	clang-tidy / cppcheck	`go vet`	内建，覆盖导入/函数调用等
文档生成	doxygen（注释标记 + 配置）	`go doc` + `godoc`	注释即文档，无需单独构建
文档注释风格	`///`、块注释 + doxygen 指令	成对注释（块首选）	`// 名称描述` 约定，导出符号必须注释
交叉编译	每平台一套交叉工具链/CI	`GOOS=linux GOARCH=amd64 go build`	一条命令 + 环境变量
静态链接	`-static` / 静态库手动组合	`CGO_ENABLED=0`	默认即可产纯静态二进制
精简体积	`-s` strip 符号	`-ldflags "-s -w"`	编译期传递 linker 参数
依赖清理	CMake/vcpkg 手工重配	`go mod tidy`	与工具链一体

三、逐主题详解

3.1 gofmt / go fmt：官方格式

# 查看差异（不修改）
gofmt -l . # 列出格式不达标的文件
gofmt -d file.go # 输出 diff 视角的差异

# 覆盖写文件
gofmt -w file.go
go fmt ./... # 等价于 gofmt -w，作用于当前包全部 .go

# gofmt 不影响语义：只重排缩进、对齐、换行、导入块

关键规则（你不需要背，工具会改）：

错误处理

Tue, 13 Oct 2026 00:00:00 +0000

Go 的错误处理哲学：error 是值，不是异常

一、Go 的错误处理哲学

1.1 与异常机制的区别

特性	Go（error）	Java/Python（异常）
表现形式	普通返回值	try-catch 机制
调用开销	零（就是多返回一个值）	较高（栈展开）
强制处理	编译器检查（必须处理）	可以不 catch
可预测性	高——每个可能出错的地方都明确	低——调用链可能随时抛异常

1.2 核心原则

// Go 的错误处理模式：每个可能出错的调用都检查返回值
result, err := doSomething()
if err != nil {
 // 处理错误：记录日志、返回错误、终止程序等
 return fmt.Errorf("doSomething failed: %w", err)
}
// 继续正常逻辑

Go 的哲学：显式胜于隐式。 没有隐藏的控制流，错误路径一目了然。

二、error 接口

2.1 error 的定义

// 标准库中 error 的定义（非常简洁）
type error interface {
 Error() string
}

任何实现了 Error() string 方法的类型都是一个 error：

// 自定义错误类型
type ValidationError struct {
 Field string
 Message string
}

func (e *ValidationError) Error() string {
 return fmt.Sprintf("validation failed on field '%s': %s", e.Field, e.Message)
}

// 使用
err := &ValidationError{Field: "email", Message: "invalid format"}
fmt.Println(err) // validation failed on field 'email': invalid format

2.2 创建错误的几种方式

import (
 "errors"
 "fmt"
)

// 1. errors.New：简单的静态错误消息
var ErrNotFound = errors.New("not found")
// 使用时
if err == ErrNotFound {
 // 处理特定错误
}

// 2. fmt.Errorf：格式化错误消息（最常用）
err := fmt.Errorf("user %d not found", userID)

// 3. %w 动词：包装（wrap）另一个错误
func getUser(id int) (*User, error) {
 err := db.Query("...")
 if err != nil {
 return nil, fmt.Errorf("getUser(%d): %w", id, err)
 // %w 保留了原始错误，可以用 errors.Is/As 检查
 }
 return &user, nil
}

// 4. 自定义错误类型（携带结构化信息）
// 见上方 ValidationError 示例

三、错误处理模式

3.1 基本模式

// 模式1：检查并返回
func processFile(path string) error {
 data, err := os.ReadFile(path)
 if err != nil {
 return fmt.Errorf("reading %s: %w", path, err)
 }
 // 处理 data...
 return nil // 成功时返回 nil
}

// 模式2：检查并记录日志 + 继续
data, err := fetchConfig()
if err != nil {
 log.Printf("config fetch failed, using defaults: %v", err)
 data = defaultConfig()
}

// 模式3：检查并终止
file, err := os.Open("critical.txt")
if err != nil {
 log.Fatal("无法打开关键文件:", err)
}
defer file.Close()

3.2 错误链（Error Wrapping）

Go 1.13+ 支持错误包装，可以构建错误链：

错误处理：error / panic / recover

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 try/catch/throw 到 Go 的显式错误返回值、panic 与 defer+recover

一、简述

Go 的错误处理哲学和 C++ 完全相反：不抛异常，而是把错误当作普通返回值显式传递。函数签名里直接写明"可能返回错误"，调用方必须处理。这套设计的核心目标：错误路径在代码里一目了然，绝不静默吞掉。

Go 提供三层错误机制：

机制	用途	类似 C++
`error` 返回值	可预期、应处理的错误（文件不存在、网络失败…）	返回码 / `std::error_code`
`panic`	不可恢复的严重错误（越界、空指针…）	`throw`
`recover`	在 defer 中捕获 panic	`catch`

核心要点：能用 error 就不要 panic。panic 是"程序无法继续"的最后手段，recover 只用于极少数场景（如防止 goroutine 崩溃拖垮整个程序）。

二、C++ 对照速查表

概念	C++	Go	关键差异
抛出错误	`throw std::runtime_error("...")`	`return errors.New("...")`	Go 是返回值，不是跳转
捕获错误	`try { } catch (const std::exception& e)`	`if err != nil { ... }`	Go 用 if 判断
错误类型	异常类层级	`error` 接口	Go 只有一个 error 接口
清理资源	RAII / 析构	`defer`	函数级，非作用域级
致命错误	`std::terminate`	`panic`	都是不可恢复
兜底捕获	`catch (...)`	`defer func() { recover() }()`	recover 必须在 defer 中
错误包装	异常嵌套	`fmt.Errorf("%w", err)`	`%w` 支持解包判断

三、error 接口

Go 的 error 是一个预定义接口：

达梦数据库学习路线（Qt/C++ 电力运维场景）

Tue, 13 Oct 2026 00:00:00 +0000

背景定位

电力设备运维场景：变电站设备经 IEC 104 规约报文上送遥测/遥信数据，需要采集、解析并落库存储。
Qt/C++ 开发背景（Qtc++）：以 Qt 技术栈（MVC、QSqlDatabase、ODBC）为主线承载数据库操作与界面联动。
国产数据库达梦（DM8）学习：从连接、SQL 到运维全链路，教学过程中与 MySQL 持续对比，突出差异。
业务代码可用伪代码表述，重点放在数据库讲解的详细性上（驱动、连接、语法、事务、运维）。

章节规划

编号	标题	内容	状态
01	Qt-MVC与达梦数据库集成	QSqlTableModel/QSqlQueryModel/QSqlRelationalTableModel + ODBC 连接达梦，报文解析→落库→界面刷新链路	✅ 已写
02	连接与驱动	ODBC 驱动安装、连接串、QSqlDatabase 建立流程、达梦 COMPATIBLE_MODE 兼容模式	⬜ 待写
03	基础SQL与MySQL对比	数据类型、建库建表、CRUD、达梦特有语法（如 DUAL、序列）、MySQL 迁移工具	⬜ 待写
04	IEC104规约报文实战	104 规约帧格式详解、报文解析、达梦落库、与界面联动	⬜ 待写
05	进阶-事务与运维	事务隔离级别、存储过程/触发器、备份恢复、性能优化、达梦集群	⬜ 待写

学习路径建议

先读 01 建立「报文→数据库→界面」整体认识，理解全链路数据流向。
再补 02/03 打牢连接与 SQL 基础，掌握 ODBC 驱动与达梦语法特性。
04 回到报文实战深挖规约，将解析与落库结合，完成闭环。
05 面向生产运维，覆盖事务、存储过程与备份恢复等工程落地能力。

进度表

当前进度：01 已写，其余四章待写，按上表顺序推进。
本路线图随笔记进度持续更新，每完成一章即同步修订状态列。

反射（reflection）

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 RTTI 只能拿到 typeid/dynamic_cast 少许信息；Go 的 reflect 能在运行时查看、遍历、修改任意类型与值

一、简述

反射（reflection）：程序在运行时检查自身的类型与结构，并据此做动态操作。Go 里就是 reflect 包：给你 reflect.Type（类型信息）和 reflect.Value（一段具体值），能动态读字段、读 tag、调方法、甚至修改可设置的值。序列化库（encoding/json）、ORM、配置解析、测试断言统统建立在这套 API 之上。但反射有显著的性能代价与脆弱性——本章教你怎么用、什么时候值得用。

核心要点：反射的入口是 reflect.TypeOf / reflect.ValueOf，一切操作都围着这两个对象转；可设置性（CanSet） 是反射修值的前提（变量要可寻址）；三大定律是官方给的使用边界。对 C++ 来说，typeid/dynamic_cast 只能做"类型识别"，Go 反射还能"改值、建新值、动态调用"，范围大得多，代价也大得多。

二、C++ 对照速查表

概念	C++	Go	关键差异
类型识别	`typeid(x).name()`	`reflect.TypeOf(x)`	C++ 只给名字，Go 给结构、字段、方法全图
运行时类型转换	`dynamic_cast<T>`（须多态）	首选类型断言 `x.(T)`；reflect 侧有 `Type.AssignableTo` / `ConvertibleTo` / `Implements` 做判断、`Value.Convert` 做转换	Go 反射不要求继承，直接看类型；reflect 包没有 `AssertableTo` 方法
遍历字段	`boost::pfr`/手写	`reflect.Value.NumField/Field`	Go 原生支持任意结构体遍历
读字段 tag	无标准机制	`reflect.StructTag.Get`	Go 的 struct tag 是反射的主要消费场景
动态改值	`*T` + `reinterpret_cast` 危险操作	`reflect.Value.Set*`	Go 有 `CanSet` 检查，越界即 panic
动态调用方法	`std::invoke`（C++17，仍要具体类型）	`reflect.Value.Method(i).Call(...)`	Go 无需编译期函数指针，纯运行时
创建新实例	`T{}` 写死 / 工厂模式	`reflect.New(T)`	反射可"凭空造值"，C++ 做不到通用
性能	零开销（编译期类型）	每次反射调用开销 ~几百 ns 起	Go 反射充满动态分派与检查
应用场景	typeid 用于调试/序列化	序列化/ORM/测试/DI	反射生态在 Go 里是日常
类型断言	C++ 无	`x.(T)` 是内置语法	注意反射 `TypeOf` + 断言可以互相换算

三、逐主题详解

3.1 反射两大入口：Type 与 Value

package main

import (
 "fmt"
 "reflect"
)

type Person struct {
 Name string `json:"name"`
 Age int `json:"age"`
}

func main() {
 p := Person{Name: "小甲", Age: 18}

 t := reflect.TypeOf(p) // 类型信息
 v := reflect.ValueOf(p) // 值信息

 fmt.Println("Type:", t) // main.Person
 fmt.Println("Kind:", t.Kind()) // struct
 fmt.Println("Value:", v) // {小甲 18}
 fmt.Println("TypeOf(v):", v.Type()) // main.Person
}

reflect.Type：描述"类型是什么"——包名、名称、Kind、字段列表、方法集、是否可比较等。URI：t.NumField()、t.Field(i)、t.Method(i)。
reflect.Value：描述"这段值是什么"——包含了底层值，可读可设（受 CanSet 约束）、可调方法、可转 interface。
Kind()：底层类别（Int、String、Slice、Struct、Map 等 26 种）。Type 是具体类型（main.Person），Kind 是粗类别（struct）——C++ 里没有直接对应，最接近 typeid 得不到 Kind；Go 里 Kind 用于判断"数据结构形状"。

3.2 从 Value 取回具体值：`Interface()`

v := reflect.ValueOf(p)
// 把 Value 还原成 interface{}
i := v.Interface()
// 再断言回具体类型
p2 := i.(Person)
fmt.Println(p2.Name) // 小甲

老代码里 v.Interface() + 类型断言是组合拳；Go 1.x 有 v.CanInterface() 检查（未导出字段、flag 受限时不可 Interface()）。
原则：反射只是"绕到类型系统后面看一眼"，看完一定要回到具体类型继续干活。

3.3 对 struct 字段遍历与 tag 读取（json 的底层原理）

func dumpStruct(s any) {
 v := reflect.ValueOf(s)
 t := v.Type()

 fmt.Printf("类型: %s\n", t)
 for i := 0; i < v.NumField(); i++ {
 field := t.Field(i) // reflect.StructField
 val := v.Field(i) // reflect.Value
 tag := field.Tag.Get("json") // 读 tag

 fmt.Printf(" 字段 %s kind=%v 值=%v tag=%q\n",
 field.Name, field.Type.Kind(), val.Interface(), tag)
 }
}

dumpStruct(Person{Name: "张三", Age: 22})
// 输出：
// 类型: main.Person
// 字段 Name kind=string 值=张三 tag="name"
// 字段 Age kind=int 值=22 tag="age"

这就是 encoding/json 的底层机制：遍历 struct 字段 → 看 json:"xxx" tag 决定键名/跳过 → 按字段类型编码/解码。
StructTag.Get("json") 可以返回 name,omitempty 这样的组合串（Lookup 可区分"有但空"和"没有"）。
字段可以是导出（大写）或未导出（小写）；未导出字段反射读值会 panic，写值 CanSet=false。

3.4 可设置性（CanSet）与修改值

反射改值前提：值必须是可以寻址的（addressable）。reflect.ValueOf(p) 拿到的是拷贝的 p——改它改不到原对象。

泛型 generics

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 template 到 Go 1.18+ 的类型参数：更克制的泛型设计

一、简述

Go 1.18 正式引入泛型（类型参数 Type Parameters）。与 C++ 模板相比，Go 泛型刻意保持简单：没有特化、偏特化、模板元编程、运算符重载，只有"类型参数 + 约束（constraint）“两个核心概念。

核心要点：Go 泛型的定位是解决"写一遍、多个类型用"的容器与工具函数问题，不是用来做编译期计算的。能用接口解决的场景，优先接口；泛型是接口的补充而非替代。

二、C++ 对照速查表

概念	C++	Go	关键差异
声明	`template <typename T>`	`func F[T any](...)`	Go 用 `[T]` 方括号
类型约束	`std::is_integral_v<T>` / requires	`T int \| float64` 或 `constraints.Ordered`	Go 用类型集（union）
特化	`template<> struct X<int>`	❌ 不支持	Go 没有特化
偏特化	`template <typename T> struct X<T*>`	❌ 不支持	Go 没有偏特化
默认参数	`template <typename T = int>`	❌ 不支持	无默认类型参数
泛型类	`std::vector<T>`	`type Vec[T any] []T`	泛型类型
泛型函数	`T max(T a, T b)`	`func Max[T constraints.Ordered](a, b T) T`	语法不同
编译期计算	模板元编程 / constexpr	❌ 无	Go 泛型是运行时类型，非代码生成
运算符重载	可对类型重载	❌ 不支持	泛型内不能直接用 `+` 除非约束允许

三、泛型函数

3.1 基本语法

// [T any] 声明类型参数；T 在参数和返回值中可用
func Min[T any](a, b T) T {
 // ❌ 编译错误：any 没有约束，不能比较大小
 // if a < b { return a }
 return b
}

问题：any 意味着"任意类型”，编译器不知道 T 是否支持 <。必须用约束声明"T 是支持比较的有序类型"：

复合类型

Tue, 13 Oct 2026 00:00:00 +0000

数组、切片、Map、结构体——Go 的复合数据结构

一、数组（Array）

Go 的数组是固定长度、同类型的值类型。

1.1 声明与初始化

// 声明：长度是类型的一部分
var arr [5]int // [0 0 0 0 0]
arr := [5]int{1, 2, 3, 4, 5}
arr := [...]int{1, 2, 3} // 编译器自动推断长度 = 3

// 指定索引初始化
arr := [5]int{1: 10, 3: 30} // [0 10 0 30 0]

1.2 数组特点

// 长度是类型的一部分
var a [3]int = [3]int{1, 2, 3}
var b [3]int = [3]int{1, 2, 3}
// a == b ✅ 同类型、同长度、同元素 → 相等

var c [4]int = [4]int{1, 2, 3, 4}
// a == c ❌ 编译错误：类型不同（[3]int != [4]int）

// 值类型：赋值和传参会复制整个数组
arr1 := [3]int{1, 2, 3}
arr2 := arr1 // arr2 是 arr1 的完整副本
arr2[0] = 100 // 不影响 arr1
fmt.Println(arr1) // [1 2 3]

// ⚠️ 实际开发中很少直接用数组，切片（slice）更常用

1.3 多维数组

matrix := [2][3]int{
 {1, 2, 3},
 {4, 5, 6},
}
fmt.Println(matrix[1][2]) // 6

二、切片（Slice）— 最核心的数据结构

切片是 Go 中最常用的复合类型。它是一个对底层数组的引用。

构建部署与 Docker 化

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的动态库/libtool 部署噩梦到 Go 的静态二进制：一个文件搞定容器化

一、简述

Go 编译产出静态二进制（前提下 CGO_ENABLED=0），没有动态库依赖、没有运行时安装（对比 C++ 的 .so/.dll + 运行时动态链接）。这让部署模型极简：

go build → 一个可执行文件
多阶段 Dockerfile（builder 编译 → 肥镜像剥离 → 瘦镜像运行）
scratch/alpine 镜像，体积通常 10~30MB
docker run / Compose 编排

C++ 部署的经典烦恼——libstdc++.so.6 not found、GLIBC_2.34 not found、ldconfig、需要把一堆 .so 一起拷走——在纯 Go 世界里直接消失。

核心要点：静态编译 + 多阶段构建演示了 Go 的部署哲学：「产物单一、环境无关」。只要你控制好 CGO 开关，一个二进制能跑在任意 Linux 上。

二、C++ 对照速查表

概念	C++	Go	关键差异
构建产物	动态库/静态库 + 可执行文件	单一可执行文件	无 `.so`/`.a` 需分发
运行时依赖	目标机需匹配 libc/动态库	`CGO_ENABLED=0` 时零依赖	拷贝即运行
版本冲突	`GLIBC_2.30 not found`、`.so` 名冲突	无（Go 自带运行时）	彻底告别 ABI 地狱
镜像方案	手动装依赖/多级 COPY .so	多阶段：build → scratch/alpine	一条 `FROM ... AS builder`
镜像体积	常见 500MB~2GB	常见 10~30MB	静态二进制省掉一层层库
基础镜像	ubuntu/debian 全量	`scratch`（空镜像）/ `alpine`	可以空到极致
健康检查	手写探针/脚本	`HEALTHCHECK` + HTTP /healthz	Dockerfile 指令
服务发现/编排	systemd / 手动进程管理	同样 systemd，但容器内单进程	容器化程度完全可控
部署步骤	装库 → 拷二进制 → 起服务	跑镜像	镜像即交付物

三、逐主题详解

3.1 go build 产物：静态优先

# 常见部署编译命令（Linux amd64、静态、精简符号）
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
go build -ldflags "-s -w" -o app ./cmd/server

# 产物检查（Linux 上）
file app
# app: ELF 64-bit LSB executable, x86-64, statically linked

# 确认没有动态链接
ldd app
# 不是 a dynamic executable

⚠️ C++ 对照：C++ 默认生成动态链接可执行文件，目标机必须带好 .so 与匹配的 libc 版本；Go 默认（cgo 关）就是静态链接。代价与取舍见 3.3。

函数、多返回值与闭包

Tue, 13 Oct 2026 00:00:00 +0000

Go 函数的设计哲学：多返回值、闭包、defer——简洁而强大

一、函数定义

1.1 基本语法

// 格式：func 函数名(参数名 类型, ...) 返回类型
func add(a int, b int) int {
 return a + b
}

C++ 对照：

概念	C++	Go
函数定义	`int add(int a, int b)`	`func add(a int, b int) int`
类型位置	类型在前 `int a`	类型在后 `a int`
多返回值	`std::pair<T1,T2>` / `std::tuple`	直接返回 `(int, string)`
函数声明	头文件 + 源文件分离	同文件（包内导出靠大小写）

1.2 参数类型简写

相邻同类型参数可以合并：

// 两种写法等价
func calc(a int, b int, c int) int { ... }
func calc(a, b, c int) int { ... } // 更简洁

1.3 没有默认参数，没有函数重载

Go 不支持默认参数和函数重载。需要类似效果时用函数选项模式或可变参数：

// 用 Option 模式替代默认参数（后面会详细讲）
type ServerOption struct {
 Addr string
 Port int
}

// 或者更简单的做法：拆成多个函数
func NewServer(addr string) *Server { ... }
func NewServerWithPort(addr string, port int) *Server { ... }

二、多返回值

这是 Go 最核心的设计之一，C++ 没有直接对应。

函数与方法

Tue, 13 Oct 2026 00:00:00 +0000

Go 的函数设计、方法接收者、闭包与高阶函数

一、函数基础

1.1 函数定义

// 基本语法
func 函数名(参数列表) 返回类型 {
 // 函数体
}

// 多参数
func add(a int, b int) int {
 return a + b
}

// 相同类型可以合并参数名
func add(a, b int) int {
 return a + b
}

// 多返回值（Go 的核心特性之一）
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a / b, nil
}

// 使用多返回值
result, err := divide(10, 3)
if err != nil {
 log.Fatal(err)
}
fmt.Println(result) // 3.3333333333333335

1.2 命名返回值

// 返回值可以有名字，相当于在函数内部声明了局部变量
func split(sum int) (x, y int) {
 x = sum * 4 / 9
 y = sum - x
 return // 裸 return，自动返回 x, y
}

// 命名返回值 + 裸 return 在短函数中可读性好
// 但长函数中容易出错，建议谨慎使用

1.3 可变参数函数（Variadic）

// 使用 ... 实现可变参数
func sum(nums ...int) int {
 total := 0
 for _, n := range nums {
 total += n
 }
 return total
}

fmt.Println(sum(1, 2, 3)) // 6
fmt.Println(sum(1, 2, 3, 4, 5)) // 15

// 传递切片给可变参数：使用 ...
nums := []int{1, 2, 3}
fmt.Println(sum(nums...)) // 6

二、函数作为值

2.1 函数是一等公民

// 函数可以赋值给变量
add := func(a, b int) int {
 return a + b
}
fmt.Println(add(1, 2)) // 3

// 函数可以作为参数传递
func apply(a, b int, op func(int, int) int) int {
 return op(a, b)
}

result := apply(10, 5, func(a, b int) int { return a - b })
fmt.Println(result) // 5

// 函数可以作为返回值
func makeMultiplier(factor int) func(int) int {
 return func(n int) int {
 return n * factor
 }
}

double := makeMultiplier(2)
fmt.Println(double(5)) // 10

三、闭包（Closure）

闭包是引用了外部变量的匿名函数。Go 中每次创建闭包都会捕获变量的引用。

环境与工具链

Tue, 13 Oct 2026 00:00:00 +0000

Go 的安装、配置与核心工具链速览

一、Go 的安装与配置

1.1 下载安装

平台	方式
Windows	下载 `.msi` 安装包：go.dev/dl
macOS	`brew install go` 或下载 `.pkg`
Linux	下载 `.tar.gz` 解压至 `/usr/local/go`

安装完成后验证：

go version
# go version go1.24.x windows/amd64

1.2 环境变量

Go 通过几个关键环境变量控制行为：

变量	作用	常用值
`GOROOT`	Go 安装目录（一般自动检测）	`/usr/local/go`
`GOPATH`	工作区目录（存放模块缓存和编译缓存）	`~/go`（默认）
`GOBIN`	`go install` 安装的可执行文件目录	`$GOPATH/bin`
`GOPROXY`	模块代理地址（国内必改）	`https://goproxy.cn,direct`
`GO111MODULE`	模块模式开关（1.16+ 默认开启）	`on`

国内加速配置（重要）：

# 永久生效（PowerShell）
go env -w GOPROXY=https://goproxy.cn,direct

# 或设置环境变量
set GOPROXY=https://goproxy.cn,direct

1.3 工作区结构（GOPATH）

GOPATH/
├── bin/ # go install 编译出的可执行文件
├── pkg/ # 编译缓存
└── src/ # [已废弃] 早期放源码，现在用 Go Modules

Go 1.16+ 不再需要把代码放在 GOPATH/src 下。使用 Go Modules 后，项目可以放在任意目录。

接口 interface

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的虚函数/抽象类到 Go 的接口：鸭子类型、隐式实现与组合式设计

一、简述

Go 的 interface 是一组方法签名的集合，它定义了类型"能做什么"，而不是"是什么"。与 C++ 的抽象类最大的不同：Go 接口是隐式实现——一个类型只要实现了接口里的所有方法，就自动满足该接口，不需要显式声明 implements。

核心要点：Go 接口让"面向接口编程"从设计原则变成了语言级强制。它催生了组合优于继承、依赖注入、mock 测试等一整套惯用法。

二、C++ 对照速查表

概念	C++	Go	关键差异
抽象接口	`class Shape { virtual double area() = 0; }`	`type Shape interface { Area() float64 }`	Go 只有方法签名，没有数据成员
实现	`class Circle : public Shape { ... }`	`func (c Circle) Area() float64 { ... }`	隐式实现，无需继承声明
多态	虚函数表 vtable + 指针/引用	接口值（类型 + 数据指针）	运行时动态分派，机制不同
空接口	`void*`	`interface{}` / `any`	表示任意类型，但不建议滥用
接口嵌套	多重继承（菱形问题）	接口嵌入接口	无菱形问题
类型断言	`dynamic_cast<T*>`	`v, ok := x.(T)`	Go 更安全：带 ok 判断
判断实现	`typeid` / 编译期检查	编译期自动检查	只要方法对上即可

三、接口的定义与实现

3.1 定义接口

// 定义接口：只声明方法，不实现
type Shape interface {
 Area() float64
 Perimeter() float64
}

3.2 隐式实现

// Circle 不需要写 "implements Shape"，只要方法对上就自动满足
type Circle struct {
 Radius float64
}

func (c Circle) Area() float64 {
 return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
 return 2 * 3.14159 * c.Radius
}

// Rectangle 同样自动实现 Shape
type Rectangle struct {
 Width, Height float64
}

func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
 return 2 * (r.Width + r.Height)
}

3.3 使用接口

func printShape(s Shape) {
 fmt.Printf("面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())
}

func main() {
 c := Circle{Radius: 1.0}
 r := Rectangle{Width: 2, Height: 3}

 printShape(c) // 传入接口参数，自动多态
 printShape(r)

 // 接口变量可以存任意实现类型
 var s Shape = c
 fmt.Println(s.Area())
}

对照 C++：C++ 必须 class Circle : public Shape 显式继承；Go 只要方法签名对上就行，实现与接口完全解耦——甚至可以给别人的类型补上方法让它满足你的接口。

接口与多态

Tue, 13 Oct 2026 00:00:00 +0000

Go 的隐式接口、空接口与面向接口编程

一、接口基础

1.1 接口定义

// 接口是一组方法签名的集合
type Reader interface {
 Read(p []byte) (n int, err error)
}

type Writer interface {
 Write(p []byte) (n int, err error)
}

// 组合多个接口
type ReadWriter interface {
 Reader
 Writer
}

1.2 隐式实现（鸭子类型）

Go 的接口是隐式实现的——不需要 implements 关键字：

// 只要一个类型实现了接口的所有方法，它就自动满足该接口
type MyReader struct {
 data []byte
 pos int
}

func (r *MyReader) Read(p []byte) (n int, err error) {
 // 实现 Read 方法
 if r.pos >= len(r.data) {
 return 0, io.EOF
 }
 n = copy(p, r.data[r.pos:])
 r.pos += n
 return n, nil
}

// MyReader 自动实现了 io.Reader 接口，无需声明
var r io.Reader = &MyReader{} // ✅ 编译通过

Go 的哲学：行为决定类型，而不是声明决定类型。 如果它像鸭子一样走路、像鸭子一样叫，那它就是鸭子。

结构体与方法

Tue, 13 Oct 2026 00:00:00 +0000

Go 没有 class，结构体(struct) + 方法(method) 是面向对象的核心替代方案

一、C++ 对照速查表

C++ 概念	Go 对应	说明
`struct`	`struct`	默认 public，字段首字母大写才导出
`class`	`struct` + 方法	Go 没有 class 关键字
`this` 指针	Receiver（值/指针）	显式声明，名字自取
构造函数	`NewXxx()` 工厂函数	没有构造函数语法
析构函数	`defer` + `Close()`	没有析构函数语法
继承 (`is-a`)	嵌入 (`has-a`)	组合优于继承，没有继承
运算符重载	不支持	Go 刻意不提供
访问控制 `private/protected/public`	首字母大小写	大写=导出，小写=包内可见
模板/泛型	泛型（Go 1.18+）	`func F[T any](x T) T`
虚函数 / 多态	接口隐式实现	鸭子类型，无需声明 implements

二、结构体定义与零值

package main

import "fmt"

// 定义结构体：type + struct 关键字
// C++ 对比：类似 struct MyPoint { double x; double y; }; 但没有方法体
type Point struct {
 X float64 // 首字母大写 = 导出字段（其他包可访问）
 Y float64
 name string // 首字母小写 = 未导出（仅本包内可访问）
}

func main() {
 // 零值：所有字段自动初始化为各自类型的零值
 // float64 -> 0.0, int -> 0, string -> "", bool -> false, 指针/切片/map -> nil
 var p Point
 fmt.Printf("零值: %+v\n", p) // {X:0 Y:0 name:}
}

三、结构体初始化

package main

import "fmt"

type User struct {
 Name string
 Age int
 Email string
}

func main() {
 // 方式1: 字面量（最常用，推荐）
 u1 := User{Name: "张三", Age: 25, Email: "zhangsan@example.com"}
 fmt.Println(u1)

 // 方式2: 按字段名初始化（部分字段，其余为零值）
 u2 := User{Name: "李四"} // Age=0, Email=""
 fmt.Println(u2)

 // 方式3: 按顺序初始化（不推荐！字段顺序变化会导致 bug）
 u3 := User{"王五", 30, "wangwu@example.com"} // 需要 import fmt 不会用到，编译器不检查字段名
 fmt.Println(u3)

 // 方式4: new 返回指针，所有字段为零值
 u4 := new(User) // *User 类型
 u4.Name = "赵六" // Go 允许对指针直接访问字段，自动解引用
 fmt.Println(u4)

 // 方式5: 声明后再赋值
 var u5 User
 u5.Name = "钱七"
 u5.Age = 28
 fmt.Println(u5)
}

NewXxx 工厂函数（替代构造函数）

// Go 没有构造函数，惯用 NewXxx 工厂函数
func NewUser(name, email string, age int) *User {
 return &User{
 Name: name,
 Age: age,
 Email: email,
 }
}

// 使用
// u := NewUser("张三", "zhangsan@example.com", 25)
// 优点：返回指针，避免大结构体拷贝；可以做参数校验

四、结构体比较

package main

import "fmt"

type Point struct {
 X int
 Y int
}

func main() {
 a := Point{1, 2}
 b := Point{1, 2}
 c := Point{3, 4}

 // 同类型结构体可以用 == 比较（逐字段比较）
 fmt.Println(a == b) // true
 fmt.Println(a == c) // false

 // 包含不可比较字段（slice, map）的结构体不能用 ==
 // type Bad struct { Data []int }
 // var x, y Bad
 // x == y // 编译错误！slice 不能比较
}

五、方法定义

package main

import "fmt"

type Rectangle struct {
 Width float64
 Height float64
}

// 值 Receiver：操作的是副本，不会修改原值
// C++ 对比：相当于 void method() const（不能修改成员）
func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

// 指针 Receiver：操作的是原值，可以修改字段
// C++ 对比：相当于非 const 的 this 指针方法
func (r *Rectangle) SetWidth(w float64) {
 r.Width = w // 直接修改原结构体
}

// String 方法实现 fmt.Stringer 接口
func (r Rectangle) String() string {
 return fmt.Sprintf("Rectangle(%.1f x %.1f)", r.Width, r.Height)
}

func main() {
 rect := Rectangle{Width: 3, Height: 4}
 fmt.Println(rect.Area()) // 12

 rect.SetWidth(5)
 fmt.Println(rect) // Rectangle(5.0 x 4.0)

 // Go 会自动处理取地址/解引用：
 rectPtr := &Rectangle{Width: 1, Height: 2}
 rectPtr.Area() // 值方法：自动解引用 (*rectPtr).Area()
 (*rectPtr).Area() // 手动解引用，效果相同

 rect2 := Rectangle{Width: 1, Height: 2}
 rect2.SetWidth(3) // 指针方法：自动取地址 (&rect2).SetWidth(3)
}

六、值 Receiver vs 指针 Receiver

选择原则

场景	推荐 Receiver	原因
只读取，不修改字段	值 Receiver	避免不必要的拷贝开销（小结构体）
需要修改字段	指针 Receiver	必须修改原值
结构体较大	指针 Receiver	避免每次调用都拷贝
实现接口	同一类型保持一致	混用会导致方法集问题（见下文）
slice/map 字段需修改	指针 Receiver	虽然 slice 底层是引用，但语义更清晰

关键区别

type Counter struct {
 Value int
}

// 值 Receiver：操作的是拷贝
func (c Counter) IncByValue() {
 c.Value++ // 修改的是副本，原值不变！
}

// 指针 Receiver：操作的是原值
func (c *Counter) IncByPtr() {
 c.Value++ // 直接修改原值
}

func main() {
 c := Counter{Value: 0}
 c.IncByValue()
 fmt.Println(c.Value) // 0 —— 没变！

 c.IncByPtr()
 fmt.Println(c.Value) // 1 —— 变了
}

七、结构体嵌入（Embedding）—— 组合优于继承

package main

import "fmt"

// 基础结构体
type Person struct {
 Name string
 Age int
}

// 嵌入 Person —— 注意：没有字段名！
// 这不是 "Person 字段"，而是把 Person 的字段和方法"提升"到 Employee 中
type Employee struct {
 Person // 嵌入（embedding），不是字段
 Company string
 Salary float64
}

// Person 的方法也会被提升
func (p Person) Greet() string {
 return fmt.Sprintf("你好，我是 %s", p.Name)
}

// Employee 自己的方法
func (e Employee) Info() string {
 return fmt.Sprintf("%s 在 %s 工作，薪资 %.0f", e.Name, e.Company, e.Salary)
}

func main() {
 // 初始化：嵌入结构体可以逐层初始化
 emp := Employee{
 Person: Person{Name: "张三", Age: 30},
 Company: "字节跳动",
 Salary: 30000,
 }

 // 字段提升：直接访问嵌入结构体的字段
 fmt.Println(emp.Name) // "张三" —— Person 的字段被提升
 fmt.Println(emp.Age) // 30
 fmt.Println(emp.Company) // "字节跳动"

 // 方法也被提升
 fmt.Println(emp.Greet()) // "你好，我是 张三"

 // 也可以显式指定
 fmt.Println(emp.Person.Name) // "张三"
}

嵌入接口

// 结构体可以嵌入接口
type Logger interface {
 Log(msg string)
}

type Server struct {
 Logger // 嵌入接口：Server 隐式实现了 Logger
 Addr string
}

// 使用时 Server 必须给 Logger 赋值，否则调用 Log 会 panic
// srv := Server{Logger: someLoggerImpl, Addr: ":8080"}

C++ 对比：嵌入 vs 继承

类型断言与 type-switch

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 dynamic_cast / typeid 到 Go 的类型断言、类型开关与反射初探

一、简述

接口变量在运行时存储了"动态类型"。当我们需要把接口值还原成具体类型、或按不同类型走不同逻辑时，就用类型断言（type assertion）和类型开关（type switch）。

核心要点：Go 类型断言是 x.(T) 语法——它是"安全的 dynamic_cast"：带 ok 判断时永远不会 panic。类型开关 switch v := x.(type) 则是处理"未知类型集合"最优雅的方式。

二、C++ 对照速查表

概念	C++	Go	关键差异
向下转型	`dynamic_cast<T*>(ptr)`	`v, ok := x.(T)`	Go 更简洁，双返回值
不安全转型	`static_cast` / `reinterpret_cast`	`v := x.(T)`	Go 会 panic（不推荐）
类型判断	`typeid(x) == typeid(T)`	`x.(type)`（type switch）	语法不同
类型名称	`typeid(x).name()`	`fmt.Sprintf("%T", x)`	运行时类型名
反射	RTTI / `<typeinfo>`	`reflect` 包	用法差异大

三、类型断言基础

3.1 语法与两种形式

var x any = 42

// 形式一：带 ok（推荐，安全）
v, ok := x.(int)
if ok {
 fmt.Println("是 int:", v) // 42
} else {
 fmt.Println("不是 int")
}

// 形式二：不带 ok（不推荐，失败直接 panic）
v2 := x.(int) // ✅ 成功
// v3 := x.(string) // ❌ panic: interface conversion

规则：永远用带 ok 的形式。不带 ok 的写法相当于 C++ 的 static_cast——假设你知道类型，错了就崩。

流程控制

Tue, 13 Oct 2026 00:00:00 +0000

if、for、switch、defer——Go 的控制流语句

一、if 条件语句

1.1 基本语法

// Go 的 if 条件不需要括号，但花括号必须存在
if score >= 60 {
 fmt.Println("pass")
} else if score >= 80 {
 fmt.Println("good")
} else {
 fmt.Println("fail")
}

1.2 if 带初始化语句

Go 的 if 可以包含一条简短的初始化语句，变量作用域仅限于 if/else 块内：

// 经典用法：同时获取值和错误
if err := doSomething(); err != nil {
 fmt.Println("error:", err)
 return
}
// 这里 err 不可用

// 读取文件的经典模式
if data, err := os.ReadFile("config.txt"); err != nil {
 fmt.Println("读取失败:", err)
} else {
 fmt.Println("内容:", string(data))
}

Go 的惯例：if err != nil 是 Go 代码中出现频率最高的模式之一。

二、for 循环

Go 只有 for 一种循环语句，但功能覆盖了 while、do-while 的场景。

2.1 三种形式

// 形式1：传统 for 循环
for i := 0; i < 10; i++ {
 fmt.Println(i)
}

// 形式2：while 风格（只有条件）
for condition {
 // ...
}

// 形式3：无限循环
for {
 // break 退出
 if done {
 break
 }
}

2.2 遍历集合

// 遍历切片/数组
nums := []int{10, 20, 30}
for i, v := range nums {
 fmt.Printf("索引=%d 值=%d\n", i, v)
}

// 只要值
for _, v := range nums {
 fmt.Println(v)
}

// 只要索引
for i := range nums {
 fmt.Println(i)
}

// 遍历 map
m := map[string]int{"Go": 1, "Java": 2}
for k, v := range m {
 fmt.Printf("%s → %d\n", k, v)
}

// 遍历字符串（按 rune 遍历）
for i, ch := range "Hello, 世界" {
 fmt.Printf("字节位置=%d 字符=%c Unicode=%U\n", i, ch, ch)
}
// 输出中 '世' 的索引是 7（不是 10），因为 range 按 rune 遍历

2.3 for-range 陷阱

// 陷阱：range 的值是副本，修改不影响原切片
nums := []int{1, 2, 3}
for _, v := range nums {
 v = v * 2 // ❌ 只修改了副本，nums 不变
}

// 正确做法：通过索引修改
for i := range nums {
 nums[i] = nums[i] * 2 // ✅ 修改原切片
}

三、switch 多分支

Go 的 switch 比其他语言更强大，默认不穿透（fall through）。

流程控制: if, for, switch

Tue, 13 Oct 2026 00:00:00 +0000

Go 的流程控制关键字精简而强大——没有 while、没有 do、switch 默认不穿透

一、C++ 对照速查表

概念	C++	Go	关键区别
条件判断	`if (cond) {}`	`if cond {}`	Go 不需要括号
初始化语句	`if (int x = f(); x > 0)` (C++17)	`if x := f(); x > 0`	语法几乎等价
基本循环	`for (init; cond; post) {}`	`for init; cond; post {}`	Go 统一用 `for`
while 循环	`while (cond) {}`	`for cond {}`	Go 无 `while` 关键字
do-while	`do {} while (cond);`	`for { ...; if !cond { break } }`	Go 无 `do-while`
无限循环	`for (;;) {}`	`for {}`	Go 写法更简洁
范围遍历	`for (auto& x : vec) {}`	`for i, v := range slice {}`	`range` 可解构 key/value
switch 穿透	默认穿透（需 `break`）	默认不穿透（需 `fallthrough`）	完全相反
switch 无条件	`switch { case ...: }`	`switch { case ...: }`	两者相同
类型判断	`dynamic_cast`/`typeid`	`switch v := x.(type)`	Go 的 type switch 更优雅
延迟执行	RAII / 析构函数	`defer`	`defer` 是函数级，非作用域级
goto	`goto label;`	`goto label;`	两者几乎相同
标号跳转	`break label`（跳出循环）	`break label`（跳出标签所在的 for）	Go 标签只对 `for` 有效

二、if 语句

2.1 基本用法——不需要括号

// Go: 条件表达式不需要括号
if x > 0 {
 fmt.Println("正数")
} else if x == 0 {
 fmt.Println("零")
} else {
 fmt.Println("负数")
}

C++ 对照：if (x > 0) { ... } — Go 省略了括号，且 { 不能另起一行（编译器自动插入分号机制）。

三色 GC 与写屏障

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 RAII/智能指针是"代码到哪回收到哪"；Go 的 GC 让事情自动发生——代价是你必须理解它何时跑、怎么跑

一、简述

Go 从 1.5 开始使用并发三色标记-清除垃圾回收器：标记阶段与应用并发跑，通过写屏障保证并发下的正确性，把 STW（Stop-The-World，全停）压缩到毫秒级。本章剖析三色算法、写屏障原理、GC 触发时机（GOGC / GOMEMLIMIT）、gctrace 日志解读，以及从 C++ 视角看"自动回收"带来的确定性问题。

核心要点：垃圾回收的本质是"追踪所有存活对象的引用图"。三色让追踪与程序运行并发，写屏障保证并发期间引用关系不变而漏标对象；GOGC==100 的意思是"堆翻倍时才触发下一次 GC"。理解这些，你才能在调优时不被玄学推着走。

二、C++ 对照速查表

概念	C++	Go	关键差异
生命周期管理	`new`/`delete`、RAII、`shared_ptr`	自动 GC	C++ 确定、Go 不确定（回收时点不定）
引用计数	手写计数 / `shared_ptr`	无引用计数	Go 用可达性分析，无循环引用问题
循环引用	`weak_ptr` 打破	天然解决	三色标记只关心可达性
悬垂指针	`shared_ptr` 防悬垂、`weak_ptr` 观测	不可能悬垂（GC 保证活着就安全）	但 `unsafe` 除外
析构时机	作用域结束/`shared_ptr` 归零	不确定（对象 GC 后才回收内存）	需要清理副作用时必须显式 `Close`
手动释放	`delete`	*不存在（`runtime.GC()` 只建议回收）	别依赖手工 GC
触发条件	无	heap 增长到阈值 / 周期 / 显式	`GOGC`、`GOMEMLIMIT` 控制
停顿	无（确定性）	少量 STW（毫秒级）	现在基本无感，但被 K8s CPU 限流仍可能抖动
代价感知	手工优化分配	分配快、回收不确定	追求低延迟要控制分配率

三、逐主题详解

3.1 为什么要 GC：先看可达性

GC 不关心"这块内存是不是有人 stack 上引用"的细节，只关心一件事：从根（root）出发，你能走到哪些对象？

数据竞争与 race 检测

Tue, 13 Oct 2026 00:00:00 +0000

C++ 的 TSan / helgrind 你在用，Go 内置了一个更好使的：go run -race 一键找数据竞争

一、简述

数据竞争（data race）：两个或多个 goroutine 并发访问同一内存位置，且至少一个是写操作，且没有任何同步（锁 / channel / 原子操作）约束它们之间的顺序。数据竞争的结果是未定义行为（UB）：读到撕裂值、编译器优化后行为诡异、crash、或者——最恼人的——偶尔才出错。

C++ 里你熟知的工具：ThreadSanitizer（TSan）、-fsanitize=thread、helgrind。Go 的对应物是内置的 race detector：

go run -race main.go # 直接跑并检测
go test -race ./... # 测试时检测（推荐）
go build -race main.go # 构建带检测的二进制（性能有损，仅调试）

核心要点：Go race detector 不是「预防工具」，而是「逮现行犯」的探针——它监测每个内存访问，报告「两个 goroutine 同时访问同一地址」的现场。加了 -race，不等于程序没问题；没加 -race，问题照样存在。 修复手段三件套：Mutex、atomic、channel 传值。

二、C++ 对照速查表

概念	C++	Go	关键差异
数据竞争定义	两个线程无同步访问同一地址	同，goroutine 版	语义一致：至少一写 + 无同步
检测工具	TSan / `-fsanitize=thread` / helgrind	`go run -race` / `go test -race`	Go 内置，零配置，一行参数
检测原理	影子内存 + happens-before 分析	同样基于 happens-before 的 shadow 内存	实现同源（Go 4 个字节内存配 8 字节影子）
共享计数器	`std::atomic<int>` / mutex	`atomic.AddInt64`（首选）	Go 原子 / 锁 / channel 三种解法都有
map 并发写	`std::unordered_map` + mutex	map 并发写 = 直接 panic	Go 有额外保护：写中读/写检测
修复手段	锁 / 原子 / 无共享	Mutex / atomic / channel 传值	第三种（传值）是 Go 特色
内存模型文档	cppreference memory_order	The Go Memory Model	Go 文档短得多，先读「happen-before」
检测开销	慢 5~15 倍	运行慢 5~~10 倍，内存多 5~~10 倍	都只该在测试/CI 用

三、逐主题详解

3.1 什么是数据竞争

判定为数据竞争需要三条同时成立：

数据库接入 database/sql · gorm · sqlx

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 sqlite3 / libpq + 手写 ORM 到 Go：database/sql 抽象层 + 驱动隔离，数据访问可以有一份标准答案

一、简述

Go 数据库世界的中心是 database/sql——一个驱动无关的 SQL 访问抽象层。就像 C++ 里 sqlite3_open、PQconnectdb 各写各的，Go 则约定「先 sql.Open 拿到抽象连接，然后 Query/Exec/事务全走同一套接口」，不同数据库只是换一个驱动 import 和连接串。sqlx 在其上补了「结构体 ↔ 行」的便捷映射；gorm 则是全功能 ORM（自动建表、关联、迁移），适合快速开发。三者是「底层 → 便捷 → 全自动」的一条谱系。

核心要点：先记住 database/sql 的三个纪律——连接池要调、行/stmt/tx 用后必关、占位符随驱动变化（MySQL 用 ?，PostgreSQL 用 $1）。在这之上，sqlx 与 gorm 都是锦上添花。

二、C++ 对照速查表

概念	C++	Go	关键差异
数据库接口	sqlite3.h / libpq 各一套	`database/sql` 标准库	统一抽象，换库只换驱动/连接串
连接池	自己写 thread pool	`sql.DB` 自带 + `SetMaxOpenConns`	连接池是 `DB` 的默认行为
查询单行	`sqlite3_step` + 手动取列	`db.QueryRow(...).Scan(&v)`	Scan 一次到位
查询多行	每列手动转换	`rows.Next()` + `rows.Scan`	循环+Scan，模板化
预处理	`sqlite3_prepare_v2`	`db.Prepare` + `stmt.Exec`	语义一致，但事务内惯用 tx 级 prepare
事务	`BEGIN/COMMIT/ROLLBACK`	`db.Begin()` + `tx.Commit/Rollback`	要 `defer tx.Rollback()` 做兜底
结构体映射	手写行→struct 拷贝	sqlx `Get`/`Select` 自动映射	tag `db:"col"` 声明式
ORM	手写/第三方（如 sqlpp11）	GORM（AutoMigrate/关联）	自动建表、crud、迁移
错误处理	返回码	`err != nil` 全链路	每步都要查

三、逐主题详解

3.1 database/sql 起步 —— Open 与连接池

sql.Open 并不会真的连数据库（Ping 才触发真实连接），它返回的 *sql.DB 是一个连接池句柄：

数组与切片

Tue, 13 Oct 2026 00:00:00 +0000

Go 的序列容器：固定长度的数组与动态的切片——切片是 Go 中最常用的数据结构

一、C++ 对照速查表

C++	Go	关键差异
`std::array<T, N>`	`[N]T`	Go 数组长度是类型的一部分，`[3]int` 和 `[4]int` 是不同类型
`std::vector<T>`	`[]T`（切片）	切片是底层数组的引用/视图，不是独立容器
`vector::push_back`	`append`	append 返回新切片，必须重新赋值
`vector::size()` / `capacity()`	`len(s)` / `cap(s)`	完全对应
`vector<T>` 赋值	切片赋值	C++ vector 赋值是深拷贝；Go 切片赋值只是拷贝引用
`std::vector<T>` (值类型)	切片是引用语义	切片共享底层数组，修改会相互影响
数组 `==` 比较	`[N]T` 支持 `==`	切片不能用 `==` 比较（只能和 `nil` 比）

核心区别：C++ 的 std::vector 是一个拥有数据的容器；Go 的切片只是一个"窗口"——包含指针、长度、容量三个字段，指向某个底层数组。

二、数组 [N]T

2.1 基本语法

// 声明：长度在类型中，不可省略
var a [5]int // 零值：[0 0 0 0 0]
b := [3]string{"hello", "go", "world"} // 字面量初始化
c := [...]int{1, 2, 3} // 编译器自动推断长度 = 3

// 长度是类型的一部分：[3]int 和 [4]int 是不同类型！
// var x [3]int = [4]int{...} // 编译错误

2.2 数组是值类型（与 C++ std::array 一致）

func main() {
 a := [3]int{1, 2, 3}
 b := a // 值拷贝，b 是 a 的副本
 b[0] = 999 // 修改 b 不影响 a

 fmt.Println(a) // [1 2 3]
 fmt.Println(b) // [999 2 3]
}

2.3 数组支持 == 比较

a := [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
fmt.Println(a == b) // true——长度相同、元素逐个相等即可比较

实际使用：Go 中几乎不用数组，绝大多数场景用切片。数组主要用于固定长度的场景（如 RGB 颜色 [3]byte、矩阵维度等）。

逃逸分析与内存分配

Tue, 13 Oct 2026 00:00:00 +0000

C++ 里 new/delete、智能指针、内存池全靠手写；Go 用逃逸分析 + 分级分配器把"栈还是堆"自动定好了

一、简述

在 Go 里写 x := 42，变量到底放栈上还是堆上，不由你说了算，由编译器说了算。这个"说了算"的过程叫逃逸分析（escape analysis）。它决定了一个变量能否安全地呆在栈上（函数返回就免费销毁），还是必须逃逸到堆（交给 GC 管理）。这直接关系到顺滑度、GC 压力与性能——理解了它，你就从"手动管内存"（C++）切换到"理解自动管内存"（Go）的思维。

核心要点：栈上分配 = 零 GC 压力、函数返回即释放；堆上分配 = 每次都要触发 GC 或分配器。逃逸分析的目标很简单：能放栈就不放堆。用 go build -gcflags="-m" 就能窥见编译器的决策过程。

二、C++ 对照速查表

概念	C++	Go	关键差异
栈上分配	`int x;`（RAII，作用域结束自动析构）	`x := 42`，若未逃逸	Go 编译器决定，不是你决定
堆上分配	`new` / `malloc`，手动 `delete`	变量逃逸时自动堆分配	Go 无需/不能手动释放
智能指针	`shared_ptr` / `unique_ptr` 管理引用	GC 统一管理	逃逸对象由 GC 回收，无引用计数
返回局部对象	悬垂指针风险（返回局部地址）	返回局部指针 → 自动逃逸到堆，安全	见下方示例，关键差异
内存池/对象池	手写 `objpool` / 复用 vector	分配器内建（mcache → mcentral → mheap）	Go 内置分级分配器
大小类(size class)	手写	编译期确定，分配器按 size class 取块	C++ 分配器可替代，Go 内建
允许拷贝后仍安全	深拷贝麻烦	值语义默认，复制即深拷贝	逃逸分析顺带优化拷贝去重
大对象堆分配	依赖 malloc 行为	>32KB 直接 mheap，不经过 mcache	阈值不同，直觉一致
接口装箱	`void*` 转换，手动管理生命周期	具体值→`interface{}` 可能逃逸	装箱常伴随逃逸

三、逐主题详解

3.1 栈 vs 堆：先建立直觉

┌─────────────────── 栈（Stack）───────────────────┐
│ main() 的帧 │
│ ├─ 局部变量 x: 42 ← 编译器决定放这 │
│ └─ 调用 f() 的帧 │
│ └─ f 返回时，这一帧整体弹出，"免费释放" │
└─────────────────────────────────────────────────┘
┌─────────────────── 堆（Heap）───────────────────┐
│ 对象：(指向它的指针被 main 拿走了) │
│ 生命周期：直到 GC 认为没人引用它才回收 │
│ 成本：分配（分配器查找空闲块）+ 回收（GC 扫描） │
└─────────────────────────────────────────────────┘

栈上的变量：随函数帧创建/销毁。函数返回时，栈指针回落，整块内存"原地废弃"——无分配成本、无释放成本、无 GC 参与。这正是 C++ 栈对象的免费午餐。
堆上的变量：生命周期逃出当前函数，必须由 GC 跟踪回收。分配要走分配器、回收要看 GC 何时跑，每一笔都有成本。

Go 与 C++ 的最大不同：C++ 里 int x; 一定在栈上、new int 一定在堆上、返回局部变量地址=悬垂指针（未定义行为）。Go 里同一段代码，编译器可能让变量留在栈上，也可能挪去堆——全看会不会"逃逸"出当前函数。返回局部变量的指针在 Go 里完全安全：

项目结构 internal/pkg/cmd

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的目录与命名空间组织到 Go 的「包即边界」：cmd/internal/pkg 是社区事实标准

一、简述

Go 没有 C++ 头文件/源文件对，也没有 C++ 那种「目录 + 命名空间」两级组织。Go 的组织单位是包（package），一个目录一个包，import 路径即模块路径 + 目录路径。一个可发布的 Go 项目结构，社区多年沉淀出了事实标准：

<repo>
├── cmd/ # 可执行程序入口（main 包）
├── internal/ # 私有代码：仅本项目可导入
├── pkg/ # 可复用库代码：对外公开
├── configs/ # 配置文件
├── scripts/ # 构建/运维脚本
└── go.mod

更向上看，Go 的哲学是 「包即层级」：包之间靠 import 建立依赖，import 循环会被编译器直接拒绝——比 C++ 的循环 include 报错更早、更严格。这天然强制了「按层依赖」的架构。

核心要点：cmd / internal / pkg 不是语言强制，而是 golang-standards/project-layout 提出的事实约定。真正由 Go 强制的是：internal 的可见性规则、每个 main 包是入口、包不能循环导入。

二、C++ 对照速查表

概念	C++	Go	关键差异
组织单位	命名空间（namespace）+ 头文件	包（package）	目录=包=导入路径，三合一
入口	`int main()`	`package main` + `func main()`	main 包即程序入口
公共接口	`namespace Foo` 内公开符号	大写导出 / 小写私有	可见性跟标识符首字母走
私有代码	pimpl / 内部命名空间 / 隐藏符号	`internal/` 目录	语言级可见性守卫
循环依赖	前置声明 + 复杂 include 图	编译器拒绝	包循环导入即编译错误
头文件	`.h` 声明 + `.cpp` 实现	一个 `.go` 文件即包的一段	无头文件，声名即定义
分层	module/backend/… 手工约定	handler→service→repository	由 import 依赖方向强制
单一大包	一个巨型头文件库	拆小而聚焦的包	Go 鼓励多包、小接口
测试辅助	测试私有符号靠 friend/内部类	`internal` 包可见	测试可直接放同包访问私有函数

三、逐主题详解

3.1 标准布局总览：cmd / internal / pkg

以 golang-standards/project-layout 为参考的常见布局：

原生 HTTP 服务 net/http

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 的 Boost.Beast / Crow 到 Go：标准库就是一套完整的 HTTP 服务器，Handler 即函数签名

一、简述

在 C++ 里写 HTTP 服务要选库（Boost.Beast 偏底层、Crow 要自己搭路由、Drogon 大而全），而在 Go 里标准库 net/http 就是一个能上生产的基础 HTTP 服务框架——路由、请求解析、响应写出、超时控制、优雅关闭全都有。它的核心哲学是「一个 http.Handler 就是一个 http.ResponseWriter 参数 + 一个 *http.Request 参数的函数」，一切中间件、路由、框架都是这个接口的装饰与组合。

核心要点：Handler 是唯一的核心接口。Go 1.22 起 http.ServeMux 原生支持「方法 + 路径」路由（"GET /users/{id}"），标准库写 REST 服务不再需要任何第三方框架。

二、C++ 对照速查表

概念	C++	Go	关键差异
HTTP 库	Boost.Beast / Crow / Drogon / cpp-httplib	`net/http` 标准库	开箱即用，零依赖起服务
处理器	继承 handler / 回调	`http.Handler` 接口 + `http.HandlerFunc`	函数签名即处理器
路由	Crow 手动匹配 / router 库	`http.NewServeMux`	Go 1.22+ 支持方法路由
路径参数	`:id` 需框架支持	`r.PathValue("id")`	ServeMux 通配符 `{id}`
服务对象	`Crow::run()`	`http.Server` 结构体	超时/监听全是 Server 字段
会话/keep-alive	手管 socket	自动，`IdleTimeout` 管空闲连接	默认开启
JSON 响应	序列化库 + 手动 header	`json.NewEncoder(w).Encode(v)`	一行流式写出
中间件	手写装饰器 / Crow 外挂	`func(http.Handler) http.Handler`	纯函数包裹，标准模式
优雅关闭	自行实现	`srv.Shutdown(ctx)`	标准库内置，等待在飞请求

三、逐主题详解

3.1 最小 HTTP 服务 —— Handler 与 HandlerFunc

任何 HTTP 服务都绕不开这两个类型：

指针 (Pointers)

Tue, 13 Oct 2026 00:00:00 +0000

Go 保留了指针的核心能力（间接寻址、传地址），但砍掉了指针算术和引用类型 &T，换来内存安全和 GC 兼容。

C++ 对照速查表

概念	C++	Go	差异说明
声明指针	`int* p` / `int *p`	`var p *int`	Go 把 `` 放在类型前*
取地址	`&x`	`&x`	完全相同
解引用	`*p`	`*p`	完全相同
指针算术	`p++`, `p + n`	不支持	Go 禁止，用切片代替
空指针	`NULL` / `nullptr`	`nil`	Go 没有 NULL 关键字
引用类型	`int& ref = x`	不存在	Go 没有引用，统一用指针
new	`new int` (调用构造)	`new(int)` → `*int`	Go 的 new 只分配零值内存，不调用构造函数
struct 访问	`ptr->field`	`ptr.field`	Go 编译器自动解引用，不需要 `->`
make	无对应物	`make([]int, 5)`	仅用于 slice/map/channel，返回初始化后的值（不是指针）

1. 指针基础：&、、T

package main

import "fmt"

func main() {
 x := 42
 var p *int = &x // p 是指向 x 的指针，*int 表示"指向 int 的指针"

 fmt.Println("x 的值：", *p) // 解引用：通过指针读取值 → 42
 fmt.Println("x 的地址：", p) // 打印地址 → 0xc0000b4008（类似）

 *p = 100 // 通过指针修改原变量
 fmt.Println("修改后 x：", x) // → 100

 // 零值：指针的零值是 nil
 var q *int
 fmt.Println("q == nil:", q == nil) // → true
}

要点：*int 的 * 是类型修饰符（“int 的指针”），*p 的 * 是操作符（“解引用”）。

字符串与 Rune

Tue, 13 Oct 2026 00:00:00 +0000

Go 字符串的本质、Unicode 处理与常用操作速查

一、简述

Go 的 string 是不可变的字节序列，底层以 UTF-8 编码存储。它是一个值类型（赋值和传参都会拷贝），长度固定后不能修改。

与 C++ std::string 最大的区别：

不可变——没有 operator[] 返回引用，不能就地修改字符
UTF-8 原生支持——但 len() 返回的是字节数，不是字符数
rune 类型——用于表示单个 Unicode 码点（int32 别名）

二、C++ 对照速查表

Go	C++	说明
`string`	`std::string`	Go 是不可变值类型；C++ 可变
`rune`	`char32_t`	`rune` = `int32`，表示一个 Unicode 码点
`byte`	`uint8` / `unsigned char`	一个字节
`len(s)`	`s.size()`	Go 返回字节数，不是字符数
`s[i]`	`s[i]`	Go 返回 `byte`；C++ 返回 `char&`（可写）
`for _, r := range s`	`for (char32_t c : s)`	Go 遍历 rune；C++ 依赖编码
`strings.Builder`	`std::ostringstream`	高效字符串拼接
`strconv.Itoa(n)`	`std::to_string(n)`	整数转字符串
`strconv.Atoi(s)`	`std::stoi(s)`	字符串转整数
`strings.Contains`	`std::string::find`	判断子串是否存在
`[]byte(s)`	`reinterpret_cast`	显式转换（会拷贝数据）
没有隐式转换	`std::string` 构造	`string` 和 `[]byte` 必须显式转换

三、代码示例

3.1 string 底层：不可变字节序列

package main

import "fmt"

func main() {
 s := "Hello, 世界"
 fmt.Println("len:", len(s)) // 13（字节数！不是字符数）

 // s[0] = 'h' // 编译错误！字符串不可变

 // 底层就是字节数组的只读视图
 b := []byte(s) // 转为 []byte 后可修改
 b[0] = 'h'
 s2 := string(b) // 再转回 string
 fmt.Println(s2) // hello, 世界
}

3.2 rune 类型与 byte vs rune

package main

import "fmt"

func main() {
 s := "Go语言"

 // byte —— 字节视角
 fmt.Println("字节数:", len(s)) // 8（G=1, o=1, 语=3, 言=3）

 // rune —— 字符视角
 runes := []rune(s)
 fmt.Println("字符数:", len(runes)) // 4

 // 每个 rune 是一个 int32，代表一个 Unicode 码点
 fmt.Printf("语 的 Unicode: U+%04X\n", runes[2]) // U+8BED
}

3.3 遍历字符串：range vs 索引

package main

import "fmt"

func main() {
 s := "Hello世界"

 // 方式一：for range —— 按 rune 遍历（推荐用于字符级操作）
 fmt.Println("=== for range ===")
 for i, r := range s {
 fmt.Printf("字节索引 %d, rune: %c (U+%04X)\n", i, r, r)
 }
 // 输出：H(0), e(1), l(2), l(3), o(4), 世(5), 界(8)
 // 注意：i 是字节索引！"世"从第5字节开始，占3字节，"界"从第8字节开始

 // 方式二：for i —— 按字节遍历
 fmt.Println("=== for i (字节) ===")
 for i := 0; i < len(s); i++ {
 fmt.Printf("s[%d] = 0x%02X\n", i, s[i])
 }
 // 中文字符的字节是 0xE4 0xB8 0xAD 这样的三字节序列

 // 方式三：转为 []rune 后按索引遍历
 r := []rune(s)
 for i := 0; i < len(r); i++ {
 fmt.Printf("r[%d] = %c\n", i, r[i])
 }
}

3.4 utf8 包

package main

import (
 "fmt"
 "unicode/utf8"
)

func main() {
 s := "Go语言"

 // 获取 rune 数量（等价于 len([]rune(s)) 但更高效）
 fmt.Println("字符数:", utf8.RuneCountInString(s)) // 4

 // 验证是否为合法 UTF-8
 fmt.Println("合法 UTF-8:", utf8.ValidString(s)) // true

 // 非法 UTF-8 字节
 bad := []byte{0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0xCF, 0x83, 0xCE, 0xBC, 0xCE, 0xB5}
 fmt.Println("合法:", utf8.Valid(bad)) // false

 // RuneLen 返回某个 rune 编码后占多少字节
 fmt.Println("语 占字节:", utf8.RuneLen('语')) // 3
}

3.5 strings 包常用函数

package main

import (
 "fmt"
 "strings"
)

func main() {
 s := " Hello, Go World! "

 // 查找
 fmt.Println(strings.HasPrefix(s, " Hello")) // true
 fmt.Println(strings.HasSuffix(s, "! ")) // true
 fmt.Println(strings.Contains(s, "Go")) // true
 fmt.Println(strings.Index(s, "Go")) // 10（字节索引）

 // 裁剪
 fmt.Println(strings.TrimSpace(s)) // "Hello, Go World!"
 fmt.Println(strings.Trim(s, " !")) // "Hello, Go World"
 fmt.Println(strings.TrimLeft(s, " H")) // "ello, Go World! "
 fmt.Println(strings.TrimSuffix("test.go", ".go")) // "test"
 fmt.Println(strings.TrimPrefix("cmd/test.go", "cmd/")) // "test.go"

 // 替换
 fmt.Println(strings.Replace("aabbcc", "bb", "xx", 1)) // "aaxxcc" (只替换1次)
 fmt.Println(strings.ReplaceAll("aabbcc", "a", "x")) // "xxbbcc" (替换所有)
 fmt.Println(strings.ReplaceAll("aabbcc", "bb", "")) // "aacc" (删除子串)

 // 分割与合并
 parts := strings.Split("a,b,c", ",") // ["a", "b", "c"]
 joined := strings.Join(parts, "-") // "a-b-c"
 fmt.Println(joined)

 // 大小写
 fmt.Println(strings.ToUpper("hello")) // "HELLO"
 fmt.Println(strings.ToLower("HELLO")) // "hello"
 fmt.Println(strings.Title("hello go")) // "Hello Go" (1.18 后建议用 cases)

 // 重复与填充
 fmt.Println(strings.Repeat("ab", 3)) // "ababab"
 fmt.Println(strings.Repeat("=", 20)) // "===================="

 // 字段分割（按空白字符）
 fields := strings.Fields(" foo bar baz ")
 fmt.Println(fields) // [foo bar baz]
}

3.6 strconv 包：类型转换

package main

import (
 "fmt"
 "strconv"
)

func main() {
 // ---- 整数 ----
 // int -> string
 fmt.Println(strconv.Itoa(42)) // "42"
 fmt.Println(strconv.FormatInt(255, 2)) // "11111111" (二进制)

 // string -> int
 n, err := strconv.Atoi("42")
 if err != nil {
 fmt.Println("转换失败:", err)
 } else {
 fmt.Println(n) // 42
 }

 // 更灵活的解析
 n2, _ := strconv.ParseInt("FF", 16, 64) // 十六进制 -> int64
 fmt.Println(n2) // 255

 // ---- 布尔 ----
 b, _ := strconv.ParseBool("true")
 fmt.Println(b) // true
 fmt.Println(strconv.FormatBool(true)) // "true"

 // ---- 浮点数 ----
 f, _ := strconv.ParseFloat("3.14159", 64)
 fmt.Println(f) // 3.14159

 // 浮点数格式化
 fmt.Println(strconv.FormatFloat(3.14159, 'f', 2, 64)) // "3.14"
 fmt.Println(strconv.FormatFloat(0.15, 'f', 10, 64)) // "0.1500000000"
 fmt.Println(strconv.FormatFloat(3.14159, 'e', 4, 64)) // "3.1416e+00"
}

3.7 string 与 []byte 的转换

package main

import "fmt"

func main() {
 s := "你好世界"

 // string -> []byte（拷贝！底层数组不共享）
 b := []byte(s)
 b[0] = 'x' // 修改不影响原字符串
 fmt.Println(string(b)) // "x好世界"
 fmt.Println(s) // "你好世界"（原字符串不变）

 // string -> []rune（按字符拆分）
 r := []rune(s)
 r[0] = '我'
 fmt.Println(string(r)) // "我好世界"

 // 频繁转换的性能提示：
 // 如果需要反复读取 []byte，先转换一次再复用，不要反复转
}

3.8 字符串拼接：三种方式

package main

import (
 "fmt"
 "strings"
)

func main() {
 // ---- 方式一：+ 运算符（简单场景，少量拼接） ----
 hello := "Hello" + ", " + "World!"
 fmt.Println(hello)

 // 注意：每次 + 都会分配新内存并拷贝
 // 循环中使用 + 拼接性能差（O(n^2)）

 // ---- 方式二：strings.Builder（推荐，高效） ----
 var builder strings.Builder
 builder.Grow(100) // 预分配容量（可选但推荐）

 for i := 0; i < 10; i++ {
 builder.WriteString(fmt.Sprintf("item%d ", i))
 }
 result := builder.String()
 fmt.Println(result) // "item0 item1 item2 ... item9 "

 // 也可以用 WriteByte, WriteRune
 builder.Reset()
 builder.WriteString("Go")
 builder.WriteByte('!')
 fmt.Println(builder.String()) // "Go!"

 // ---- 方式三：strings.Join（拼接已有切片） ----
 items := []string{"apple", "banana", "cherry"}
 joined := strings.Join(items, " | ")
 fmt.Println(joined) // "apple | banana | cherry"
}

3.9 fmt.Sprintf 格式化

package main

import "fmt"

func main() {
 // 基本格式化
 fmt.Printf("整数: %d, 浮点: %f, 字符串: %s\n", 42, 3.14, "hello")

 // Sprintf 返回字符串而非打印
 s := fmt.Sprintf("年龄: %d, 成绩: %.1f%%", 18, 95.5)
 fmt.Println(s) // "年龄: 18, 成绩: 95.5%"

 // 常用格式动词
 fmt.Printf("十进制: %d\n", 255)
 fmt.Printf("八进制: %o\n", 255) // 377
 fmt.Printf("十六进制: %x\n", 255) // ff
 fmt.Printf("十六进制(大写): %X\n", 255) // FF
 fmt.Printf("二进制: %b\n", 255) // 11111111
 fmt.Printf("Unicode: %U\n", '语') // U+8BED
 fmt.Printf("字符: %c\n", 8364) // € (欧元符号)

 // 宽度与对齐
 fmt.Printf("[%10s]\n", "right") // [ right]
 fmt.Printf("[%-10s]\n", "left") // [left ]
 fmt.Printf("[%05d]\n", 42) // [00042]

 // 结构体格式化
 type Person struct {
 Name string
 Age int
 }
 p := Person{"Alice", 30}
 fmt.Printf("%+v\n", p) // {Name:Alice Age:30}
 fmt.Printf("%#v\n", p) // main.Person{Name:"Alice", Age:30}
 fmt.Printf("%T\n", p) // main.Person

 // 错误处理常用
 err := fmt.Errorf("文件 %s 不存在 (行号: %d)", "config.txt", 42)
 fmt.Println(err)
}

3.10 多行字符串

package main

import "fmt"

func main() {
 // ---- 反引号：原生字符串（推荐） ----
 // 不能包含反引号本身，不处理转义符
 raw := `
 第一行
 第二行（有缩进）
 \n 这不是换行，是字面量
 `
 fmt.Println(raw)

 // ---- 双引号 + 转义 ----
 escaped := "第一行\n第二行\n\t\t缩进\n路径: C:\\Users\\test"
 fmt.Println(escaped)

 // 反引号常用于：正则、SQL、模板、路径
 regex := `^\d{3}-\d{4}$`
 fmt.Println(regex) // 不需要转义反斜杠
}

四、常见坑

坑 1：len() 返回字节数，不是字符数

s := "你好"
fmt.Println(len(s)) // 6，不是 2！
fmt.Println(utf8.RuneCountInString(s)) // 2（正确获取字符数）

教训：涉及中文等多字节字符时，用 utf8.RuneCountInString() 或 len([]rune(s))。

综合项目实战记录（短链接服务）

Tue, 13 Oct 2026 00:00:00 +0000

把前面四篇的东西缝合起来：一个「从需求到 Docker 部署」的完整短链接服务，走一遍 Go 工程化的真实流程

一、简述

短链接服务是一个完美的「毕业设计」：需求明确、覆盖路由/存储/并发/测试/构建全链路、不引入任何第三方 Web 框架也能跑（正适合巩固 net/http）。本文按真实开发顺序走：需求分析 → 目录设计 → 存储接口 → 短码生成 → HTTP 路由 → 计数 → 单元测试 → go mod → 构建与 Docker。

核心要点：这个项目刻意只用标准库写 HTTP（把 02-原生HTTP服务-net-http 练扎实），存储接口先给内存实现、日后可平移到 04-数据库接入-database-sql-gorm-sqlx 的 database/sql/gorm。它演示的是 Go 工程化的结构：cmd/ 装入口、internal/ 装业务、store 是抽象边界。

二、C++ 对照速查表

概念	C++	Go	关键差异
工程布局	src/ + CMake targets	`cmd/` + `internal/`	目录即包，internal 强制隔离
抽象接口	抽象基类/接口类	`interface{}` 接口（store.URLStore）	鸭子类型式，一个接口多个实现
短码生成	自写 base62	自写（本项目实现）	逻辑两端一致，关注冲突处理
重定向	手写响应头 `Location`	`http.Redirect(w, r, url, 302)`	标准库一行
并发安全	`std::mutex` / `std::atomic`	`sync.RWMutex` + map	读写锁分离，并发读不死锁
单元测试	gtest/test framework	`testing` + `go test`	table-driven 是惯例
构建	CMake/ninja	`go build ./cmd/server`	单二进制，静态链接
容器化	手写 Dockerfile 依赖编译环境	`golang` builder 镜像 + 多阶段	官方镜像成熟，CGO 关掉即纯静态

三、逐主题详解

本项目按「需求 → 结构 → 代码 → 测试 → 构建 → 部署」的顺序推进，每一小步都有可直接运行的代码片段。

STM32 GPIO 入门三连：点亮 LED、流水灯与蜂鸣器

Tue, 08 Sep 2026 00:00:00 +0000

环境配好、接线踩坑之后，接下来就是让外设动起来。这组实验全部围绕 GPIO 输出：先点亮一颗 LED，再扩展成八路流水灯，最后用同样的思路驱动蜂鸣器。三个实验的代码都在工程的 User\main.c 里（如 3-1点亮LED灯、3-2流水灯、3-3蜂鸣器）。

一、点亮第一颗 LED

之前两天都在跟接线较劲，怀疑人生；当 LED 终于亮起来的时候，成就感爆棚。核心教训：嵌入式开发，硬件接线和软件一样重要。

// PA0 配置为推挽输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

// 低电平点亮 LED
GPIO_ResetBits(GPIOA, GPIO_Pin_0);

关键理解：

GPIO 配置：推挽输出模式，速度 50MHz
LED 驱动：低电平有效，GPIO_ResetBits 拉低点亮
当前状态：常亮，while(1) 为空

二、流水灯：PA0-PA7 八个 LED

在单颗 LED 的基础上，实现 PA0-PA7 八个 LED 流水灯效果。

// 配置 GPIOA 所有引脚为推挽输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // 一次性配置所有引脚
GPIO_Init(GPIOA, &GPIO_InitStructure);

// 流水灯核心：GPIO_Write 一次写入 16 位数据
while(1)
{
 GPIO_Write(GPIOA, ~0x0001); // 0x0001取反=0xFFFE，PA0低电平点亮
 Delay_ms(300);
 GPIO_Write(GPIOA, ~0x0002); // PA1点亮
 Delay_ms(300);
 GPIO_Write(GPIOA, ~0x0004); // PA2点亮
 // ... 依次类推到 PA7
}

GPIO 操作函数对比

函数	作用	使用场景
`GPIO_ResetBits`	单引脚拉低	单个LED控制
`GPIO_SetBits`	单引脚拉高	单个LED控制
`GPIO_WriteBit`	按位设置	单引脚精确控制
`GPIO_Write`	16位整体写入	多引脚同时控制

位操作技巧

~0x0001 = 0xFFFE → PA0 低电平（点亮），其余高电平（熄灭）
~0x0002 = 0xFFFD → PA1 低电平（点亮）
位左移：0x0001 << n 可以简化代码

优化思路

当前代码是 8 行重复，可以用循环 + 移位简化：

STM32 学习 Day01：开发环境配置与面包板接线踩坑

Mon, 07 Sep 2026 00:00:00 +0000

STM32 学习第一天：配置开发环境、熟悉 ST-Link 调试器、学面包板接线。技术内容不多，但接线的两个坑值得记下来。

一、完成内容

配置 STM32 开发环境
熟悉 ST-Link 调试器使用
学习面包板接线基础

二、挫折与踩坑

挫折 1：供电原理不懂

不知道最小系统板如何为面包板供电
浪费大量时间在接线上，LED 一直不亮
教训：先搞清楚供电回路，再动手接线

挫折 2：接线思维误区

误认为面包板格子位置是唯一的对应关系
反复检查接线，始终找不到问题
顿悟：接线要看最小系统板引脚图，不是看面包板格子
这个错误卡了很长时间，一度怀疑开发板坏了

三、收获

ST-Link 调试器接线已熟练掌握
开发板接线基本熟悉

第一天的核心体会：接线问题比想象中更消耗时间——供电回路和引脚对应关系没搞清楚之前，LED 不亮根本无从判断是哪里的问题。

C++ 服务部署实战：从源码到公网访问

Tue, 25 Aug 2026 00:00:00 +0000

在一台 2C2G 的云服务器上实测：单文件 HTTP 服务器，g++ 编译，监听 8080 端口，从编译到公网访问全流程跑通。

1. socket 七步流程

示例是一个约 60 行的单文件程序 http_server.cpp，纯 Linux socket API、零第三方依赖，放在你自己的项目目录里即可。

socket() → bind() → listen() → accept() → recv() → send() → close()
 建电话 插网线 开机待命 接电话 听需求 答复 挂断

步骤	调用	说明
1	`socket(AF_INET, SOCK_STREAM, 0)`	IPv4 + TCP，返回文件描述符（Linux 一切皆文件）
2	`bind(fd, &addr, sizeof)`	绑定地址；`INADDR_ANY`（0.0.0.0）= 监听所有网卡
3	`listen(fd, 16)`	开始待命；16 是 backlog 等待队列长度
4	`accept(fd, ...)`	阻塞等客户端，返回新 fd（每客户一个）
5	`recv(fd, buf, n, 0)`	读 HTTP 请求报文（原始文本）
6	`send(fd, resp, len, 0)`	回 HTTP 响应
7	`close(fd)`	挂断，回 while 等下一客

要点：

C++ 后端学习路线：以云服务器为练兵场

Tue, 25 Aug 2026 00:00:00 +0000

目标：从零起步，拿一台 2C2G 的云服务器当主战场，系统学习 C++ 后端开发。原则：基础 → 系统 → 网络 → 框架 → 工程化，渐进推进；每个阶段都在云服务器上产出可运行的作品。

总览

阶段	主题	周期	云服务器上的产出
0	Linux 基础与服务器上手	起步阶段，边用边补	workspace 工作目录、用户与权限体系
1	现代 C++ 核心	2-4 周	编译与工具链的熟练度
2	Linux 系统与网络编程	4-6 周	手写并发 HTTP 服务器
3	框架与中间件	6-8 周	Drogon + MySQL + Redis 的 REST API
4	工程化与云原生	持续	Docker 化部署 + CI/CD + 监控

时长按「每天 1-2 小时」估算，弹性理解；项目驱动，不以周数为硬指标。

阶段 0 不必一次啃完：进程管理、看日志、shell 脚本这些内容在后面每个阶段都会反复用到，随用随补即可。

阶段 0：Linux 基础与服务器上手

这一层要覆盖的内容：

Linux 基础操作：目录结构、磁盘分区与权限

Tue, 25 Aug 2026 00:00:00 +0000

适用读者：有 C++/Qt 基础（熟悉 QDir / QFile），手边有一台云服务器（示例环境：Alibaba Cloud Linux，2 核 / 2G / 40G 系统盘）。主线：每条命令都在真实服务器上跑过，边用边理解。

1. 根目录里都有什么

ls / 看到的目录（Alibaba Cloud Linux 实测）：

bin dev home lib64 media opt root sbin swapfile tmp var
boot etc lib lost+found mnt proc run srv sys usr

这些目录不是平级无关的文件夹，而是各司其职（FHS 标准约定）：

目录	放什么	类比 Windows
`/etc`	系统与服务配置文件	`C:\Windows\System32` 配置
`/usr`	系统软件与库（最大）	`C:\Program Files`
`/var`	经常变化的数据：日志、缓存	`C:\ProgramData` 日志
`/home`	普通用户的家目录	`C:\Users\`
`/root`	root 用户的家目录（不在 `/home` 里）	—
`/tmp`	临时文件，重启可能清空	`%TEMP%`
`/opt`	第三方大软件	`D:\Software`
`/boot`	启动引导文件	—
`/proc` `/sys` `/dev` `/run`	内存虚拟文件系统，不在磁盘上	—
`lost+found`	ext4 文件系统 fsck 修复碎片（有它说明 `/` 是 ext4）	磁盘扫描碎片
`swapfile`	交换文件（小内存机器用文件代替交换分区）	虚拟内存 `pagefile.sys`

💡 /proc 里的数字目录就是进程 PID——内核把进程信息伪装成文件给你看，cat /proc/cpuinfo 就是读 CPU 信息。

最常用 Git 命令速查：三区模型、场景命令表与五个坑

Tue, 25 Aug 2026 00:00:00 +0000

适用人群：Git 零基础起步，以日常笔记仓库为练习场。主线：先记住「三区模型」，命令自然就懂了。

1. 核心要点：先建立「三区」心智模型

核心要点：90% 的 Git 疑惑都源于不知道「文件现在在哪个区」。Git 有三个区域——工作区 → 暂存区 → 本地仓库，再加一个远程仓库。所有常用命令本质上就是在这些区之间搬东西。

工作区 暂存区 本地仓库 远程仓库
(你编辑的文件) (git add 后) (git commit 后) (GitHub 等)
 │ git add │ git commit │ git push │
 ├──────────────▶├─────────────────▶ ├───────────────────▶ │
 │◀──────────────┤◀───────────────── ├── ◀─────────────────┤
 │ git restore │ │ git fetch / pull │

区	是什么	对应命令
工作区	你正在编辑的目录	`git status` 里红色的文件
暂存区	下次 commit 要打包的内容	`git add` 之后变绿色的文件
本地仓库	已提交的历史（`.git/` 目录）	`git log` 能看到的
远程仓库	别人/其他机器上的副本	`git push` / `git pull` 打交道

2. 常用命令速查表（按场景）

2.1 首次配置与建仓

命令	作用	备注
`git config --global user.name "xxx"`	设置全局用户名	提交记录会显示它
`git config --global user.email "xxx@xx.com"`	设置全局邮箱	GitHub 用它关联头像/贡献图
`git init`	当前目录变成 Git 仓库	生成隐藏的 `.git/`
`git clone <url>`	克隆远程仓库到本地	自带远程连接

2.2 日常四件套（用得最多）

命令	作用
`git status`	看当前状态：哪些改了、哪些暂存了（最常打）
`git add <file>` / `git add .`	把文件放入暂存区；`.` 表示全部
`git commit -m "说明"`	把暂存区内容打包成一次提交
`git log --oneline`	一行一条看提交历史

2.3 查看差异与历史

命令	作用
`git diff`	工作区 vs 暂存区的改动
`git diff --staged`	暂存区 vs 上次提交的改动
`git show <commit>`	看某次提交的具体内容
`git blame <file>`	看文件每行是谁、哪次提交写的

2.4 撤销与回退（救火）

命令	作用	危险度
`git restore <file>`	丢弃工作区改动（未 add）	⚠️ 改动不可恢复
`git restore --staged <file>`	取消暂存（add 反悔），保留改动	安全
`git reset --soft HEAD~1`	撤销上次 commit，保留改动在暂存区	安全，改说明重提最常用
`git revert <commit>`	生成一个「反向提交」抵消指定提交	✅ 最安全，适合已 push 的场景

2.5 分支

命令	作用
`git branch`	列出本地分支，`*` 标记当前分支
`git branch <名字>`	新建分支（不切换）
`git switch <名字>`	切换分支
`git switch -c <名字>`	新建并切换（= `-b`）
`git merge <分支>`	把指定分支合并进当前分支
`git branch -d <名字>`	删除已合并的分支

2.6 远程协作

命令	作用
`git remote -v`	看远程仓库名和地址
`git remote add origin <url>`	关联一个远程仓库
`git push -u origin main`	首次推送并建立跟踪关系
`git push`	推送（之后简写即可）
`git fetch`	只下载远程更新，不合并（先看看再说）
`git pull`	下载并合并 = `fetch` + `merge`

3. 高频组合拳

# 场景1:日常保存进度(写笔记的标准流程)
git status # 先看有什么变动
git add path/to/note.md # 只加想提交的文件
git commit -m "feat(模块): 添加 xx 笔记"
git push

# 场景2:commit 说明写错了,想重写
git reset --soft HEAD~1 # 退回但保留改动
git commit -m "正确的说明"

# 场景3:某个文件改坏了,恢复到最后一次提交的状态
git restore 文件名

# 场景4:push 被拒(远程有新提交)
git pull # 先拉下来合并
git push # 再推

# 场景5:实验性改动,开个分支玩
git switch -c try-something
# ...随便折腾...
git switch main # main 完全不受影响

4. 常见坑与误区

⚠️ 坑 1：把不该提交的文件 add 进去了（如编辑器/助手的本地配置、进度笔记等本地配置层） → 现象：git status 里出现不想推的文件。 → 原因：git add . 会把所有文件一网打尽。 → 正确写法：精确指定文件名来 add；长期排除则写进 .gitignore；已被跟踪的用 git rm --cached 文件名 取消跟踪（本地文件保留）。

云服务器认识与使用：从虚拟机到公网部署

Fri, 21 Aug 2026 00:00:00 +0000

适用读者：有 C++/Qt 开发基础，用 VMware 虚拟机跑过 Linux、做过 Qt 界面开发，正在学 Go，手边有一台入门配置的云服务器（示例：2 核 / 2G / 40G）。主线：先用起来，再理解原理。

1. 认识：你买的到底是台什么机器

核心要点：云服务器不是神秘的新东西——它就是「一台放在数据中心里、常年开机、你通过 SSH 远程使用的 Linux 电脑」，和你在 VMware 里装的那台 Ubuntu 骨子里是同一种东西。

1.1 先回忆：你在虚拟机里做过什么

用 VMware 装一个 Ubuntu 服务器版，在里面跑现成的后端程序、做 Qt 界面开发。
这台 Ubuntu 是「一台软件模拟出来的电脑」，运行在你自己的 Windows 上。
你能 ssh 连它、在里面装服务、跑程序——这些和云服务器上的操作几乎一模一样。

💡 为什么先从虚拟机讲起：你已经在「一台假的服务器」上做过大部分操作了。云服务器只是把「这台假的」换成「一台真的、别人帮你放在机房的」。

1.2 两个易混的词：「服务器」和「服务端」

词	含义	举例
服务器 (Server)	一台长期开机的电脑（硬件 + 系统）	你的云上主机、机房里的物理机
服务端 (Server-side)	一种软件的运行角色，相对客户端而言	你用 Qt 写的 TCP Server、Nginx、MySQL、Go 的 HTTP 服务

「开启服务器端」= 在某个服务器上，把一个服务程序跑起来并对外提供功能。
这个程序跑在哪台机器上都行（本机、虚拟机、云服务器），区别只在谁能访问到它——这一点正是第 2 章的核心。

1.3 一台服务器由什么组成

组成部分	作用
硬件	CPU、内存、磁盘、网卡——决定这台机器能干多重的活
操作系统	你熟悉的 Linux（Ubuntu、Alibaba Cloud Linux、CentOS 等）
服务软件	提供业务能力的程序：Nginx、MySQL、你的 Go 后端
IP / 端口 / 域名	IP 定位机器、端口定位机器上的程序、域名给人好记

2. 区别：云服务器 vs 虚拟机「开启服务器端」

核心要点：技术层面你几乎不换思路——都是「Linux + 服务程序」。真正的差别在 4 件事：谁能访问、关机了怎么办、坏了谁来修、按什么计费。

Posts on 鹿鸣青野的blog

AI 时代 Qt 开发新路线(ACP + 专家模式)

目录

1. 时代背景:IDE 接入 ACP

2. qt专家模式:降低 LLM 幻觉的核心手段

atomic 原子操作

一、简述

二、C++ 对照速查表

三、逐主题详解

3.1 计数器：AddInt64 / AddUint64

Boost.Asio 回调机制初步窥探

一、环境验证：异步定时器

C/C++ 内存布局、程序构建与静态库动态库

一、内存布局在构建阶段就确定

1. .text 代码段（文本段 / 代码区）

2. .rodata 只读数据段（常量区）

C++ namespace、const 与 constexpr 知识点总结

1. namespace 命名空间

1.1 基本声明与使用

1.2 命名空间的特点

1.3 嵌套命名空间

1.4 匿名命名空间

C++ 并发编程：互斥锁、条件变量与原子操作

核心概念速查

为什么需要锁

互斥锁三种用法

条件变量：生产者-消费者

原子操作

死锁

常见坑

顿悟

自测清单

C++ 函数指针、std::function 与 lambda

核心概念速查

为什么需要函数指针

函数指针基础语法

C++ 基础遗漏知识点：bool、sizeof、auto、nullptr 与 static

1. bool 类型与 boolalpha

核心规则

boolalpha 操纵符

常见陷阱

2. sizeof 运算符

基本用法

动态数组的 sizeof 陷阱

3. auto 关键字（C++11）

基本用法

注意事项

4. nullptr（C++11）

与 NULL 的区别

最佳实践

5. const 与 constexpr（简记）

C++ 网络编程基础：Socket API 与 TCP 通信

核心概念速查

TCP 三次握手与四次挥手

TCP 客户端-服务器模型

核心函数对照表

从 Qt 到原生 Socket

C++ 线程基础：std::thread、join/detach 与传参陷阱

核心概念速查

进程 vs 线程

创建线程

join 与 detach

C++ 项目约定：目录结构、依赖管理、构建与 Git

一、总体原则

二、目录结构约定（Windows 端）

channel 详解

一、简述

二、C++ 对照速查表

三、逐主题详解

3.1 创建 channel：make

CLI 工具 flag 与 cobra

一、简述

二、C++ 对照速查表

三、逐主题详解

3.1 os.Args —— 原始参数切片

CMake 工程模板：VS2022 + Boost（静态库）

一、目录结构

二、CMakeLists.txt（复制到项目根目录）

三、CMakePresets.json（复制到项目根目录）

CMake 工程模板：VS2022 + OpenCV 4.10

3.1 计数器：`AddInt64` / `AddUint64`

1. `.text` 代码段（文本段 / 代码区）

2. `.rodata` 只读数据段（常量区）

3.1 创建 channel：`make`

3.1 两个根：`context.Background()` 与 `context.TODO()`