C++

验证 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 证明了三件事： ...

从内存区域划分（.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 变量本质还是在栈上。 ...

命名空间、常量限定符与编译期常量三件套：语法、特点表、易混点（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 全局变量/函数，用于隔离实现细节。 ...

线程创建与 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

“把函数当值用"的三种写法：函数指针、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(...) 就变成返回指针的函数了。 ...

容易被忽略但常出问题的基础语法点：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 知识点总结》。 ...

围绕 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 管理、字节序、事件分发）亲手做一遍。 ...

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 的线程访问已销毁的对象 → 未定义行为。 ...

在一台 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 等下一客 要点： ...

目标：从零起步，拿一台 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 基础与服务器上手 这一层要覆盖的内容： ...