standrad c++

1. 传统格式化方式的痛点

在 C++17 以前，字符串格式化主要依赖于 printf 系列函数、std::ostringstream、以及第三方库如 fmt。

• printf 语法不安全，类型不匹配会导致未定义行为。
• ostringstream 语法冗长，性能不如 printf。
• 第三方库需要额外依赖，且 API 与 C++ 标准库不一致。

2. C++20 引入 std::format

C++20 在 `

` 头文件中提供了 `std::format`，其设计灵感来自 Google 的 `fmt` 库，兼具安全性、可读性与高性能。 ### 2.1 语法与使用 “`cpp #include #include int main() { std::string name = “Alice”; int age = 30; double salary = 12345.678; std::string msg = std::format( “姓名：{}，年龄：{: buf(1024); std::format_to(std::back_inserter(buf), “点数: {}”, 42); std::string result(buf.begin(), buf.end()); “` ## 3. 与 `std::printf` 的对比 | 特性 | `std::printf` | `std::format` | |——|—————|—————| | 类型安全 | 否 | 是 | | 编译期检查 | 否 | 是 | | 对齐/宽度 | `%5d` | `{:n}` | 右对齐 | `”{:>5}”.format(42)` → `” 42″` | | `{:^n}` | 居中 | `”{:^5}”.format(42)` → `” 42 “` | | `{:x}` | 十六进制 | `”{:x}”.format(255)` → `”ff”` | | `{:03d}` | 前导 0，宽度 3 | `”{:03d}”.format(7)` → `”007″` | | `{:f}` | 浮点 | `”{:.2f}”.format(3.1415)` → `”3.14″` | ## 5. 如何在项目中使用 `std::format` 1. **编译器支持** – GCC ≥ 11、Clang ≥ 13、MSVC ≥ 19.28 支持 ` `。 – 若使用较旧编译器，可回退到 `fmt` 库。 2. **链接** – 标准库已包含实现，无需额外链接。 – 若编译器未完整实现，可能需要 `-lstdc++fs` 或类似标志。 3. **示例** “`cpp #include #include #include void log_error(const std::string& file, int line, const std::string& msg) { std::string out = std::format(“[{}:{}] ERROR: {}\n”, file, line, msg); std::ofstream log(“app.log”, std::ios::app); log

在 C++20 标准中，std::span 被引入为一种轻量级、非拥有的视图，能够安全、高效地对数组、std::vector、以及连续内存块进行切片和访问。相比传统的裸指针加长度的组合，std::span 提供了更直观的语义、内置的边界检查、以及兼容性强的 API，适用于需要频繁传递子数组的场景。

1. 基本概念

• 非拥有：std::span 不管理底层内存的生命周期，它只存储指向首元素的指针和元素数量。
• 连续性：只能用于连续内存的数据结构（如数组、std::vector、std::array）。
• 类型安全：编译器会检查类型是否匹配，避免类型错误。

2. 声明与初始化

#include <span>
#include <vector>
#include <array>
#include <iostream>

int main() {
    // 从数组创建 span
    int arr[] = {1,2,3,4,5};
    std::span <int> sp1(arr);                     // 自动推断大小
    std::span <int> sp2(arr, 3);                  // 指定大小

    // 从 std::vector 创建 span
    std::vector <int> vec = {10,20,30,40,50,60};
    std::span <int> sp3(vec);                     // 自动推断
    std::span <int> sp4(vec.data(), 4);           // 手动指定

    // 从 std::array 创建 span
    std::array<int, 5> aarr = {100,200,300,400,500};
    std::span <int> sp5(aarr);

    // 常量视图
    std::span<const int> const_sp = sp1;         // 只读
}

3. 访问与遍历

std::span 提供了类似容器的接口：

for (int x : sp3) {
    std::cout << x << ' ';
}
std::cout << '\n';

for (size_t i = 0; i < sp3.size(); ++i) {
    std::cout << sp3[i] << ' ';
}

此外，还可以使用 begin()、end()、data() 等标准容器方法。

4. 切片（子视图）

std::span 的 subspan() 方法可以创建原始视图的子视图，而不需要复制数据。

auto sub = sp3.subspan(2, 3); // 从索引 2 开始，长度 3
// sub 视图包含 vec[2], vec[3], vec[4]

如果只指定起始位置，子视图会持续到原始视图末尾：

auto tail = sp3.subspan(4);   // 从索引 4 开始，长度自动推断

5. 边界检查

• 构造：std::span 的构造函数不会自动检查边界；如果你使用 std::array 或 std::vector，构造时大小与实际长度相符。
• 访问：使用 at() 访问元素会在调试模式下进行边界检查；使用 operator[] 则不检查。
• 子视图：subspan() 在调试模式下会检查起始位置和长度是否合法。

6. 性能优势

• 零成本抽象：std::span 在编译期被消除，实际产生的对象只有指针与长度两字段，完全不增加运行时开销。
• 内存复制避免：切片仅传递视图，不涉及数据复制，适合大数据切片场景。
• 兼容性：既可以直接用作函数参数，也能与旧代码的裸指针兼容。

7. 与传统指针比较

方案	优点	缺点
int* + size_t	简单、低级别	需要手动管理边界，易出错
`std::vector
`	动态大小、管理生命周期	复制时会复制元素，额外内存
`std::span
`	轻量、安全、可切片	仅支持连续内存，不可直接持久化

8. 实战案例：快速排序子数组

void quicksort(std::span <int> sp) {
    if (sp.size() <= 1) return;
    int pivot = sp.back();
    size_t i = 0, j = sp.size() - 1;
    while (i < j) {
        while (sp[i] <= pivot && i < j) ++i;
        while (sp[j] >= pivot && i < j) --j;
        std::swap(sp[i], sp[j]);
    }
    std::swap(sp[i], sp.back());
    quicksort(sp.subspan(0, i));
    quicksort(sp.subspan(i + 1));
}

这段代码展示了如何在不复制数组的情况下，对任意子区间递归排序。

9. 小结

std::span 为 C++20 引入的一个强大工具，它在保持极低运行时成本的同时，提升了代码可读性与安全性。对于需要频繁传递子数组、切片或只读视图的场景，推荐优先使用 std::span，既避免了指针带来的隐患，又享受了容器 API 的便利。

在后续的 C++ 开发中，合理利用 std::span 可以让代码更简洁、更易维护，并且在性能上几乎与裸指针相当，甚至更好。希望这篇文章能帮助你快速掌握并应用 std::span。

在 C++20 标准中，协程（Coroutines）被正式纳入语言规范，为异步编程提供了更直观、性能更优的解决方案。与传统的回调、线程或手动状态机相比，协程让代码更接近同步写法，同时保持非阻塞和高效。本文将从协程的基本概念、关键语法到实战案例，逐步展开讲解。

---

一、协程的核心概念

1. 暂停与恢复
   协程通过 co_await、co_yield、co_return 关键字在执行过程中“挂起”与“恢复”，使得函数可以在多个点暂停执行，随后从上一次挂起的位置继续。

2. 生成器（Generator）与任务（Task）

   • Generator：使用 co_yield 产生一系列值，类似于 Python 的生成器。
   • Task：使用 co_return 返回最终结果，类似于 Future/Promise。

3. 协程的句柄（Coroutine Handle）
   每个协程都有一个句柄 std::coroutine_handle，它可用来检查协程是否已完成、主动恢复或销毁协程。

---

二、关键语法与实现细节

关键字	作用	典型示例
co_await	等待一个 awaitable 对象，协程挂起直到其完成	int value = co_await asyncRead();
co_yield	生成一个值，暂停协程，让调用者获取该值	co_yield i;
co_return	返回最终值，结束协程	co_return result;
co_await 前的 co_ 前缀	标识协程操作，编译器会生成相应的 state machine	co_await std::suspend_always{};

Awaitable 类型
任何具备以下成员的类型都可以作为 awaitable：

struct Awaitable {
    bool await_ready() const noexcept;
    void await_suspend(std::coroutine_handle<> h) noexcept;
    T await_resume() noexcept;
};

• await_ready()：判断是否需要挂起。
• await_suspend()：挂起协程，传入当前句柄。
• await_resume()：协程恢复时返回的值。

---

三、实战示例：异步文件读取

下面给出一个完整的协程实现，用来异步读取文件内容，并返回字符串。示例使用了 std::filesystem 和 std::future 作为后端异步机制。

#include <coroutine>
#include <future>
#include <fstream>
#include <string>
#include <iostream>

struct AsyncReadResult {
    std::string data;
    bool success;
};

struct AsyncReadAwaitable {
    std::string filename;
    std::promise <AsyncReadResult> promise;

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) {
        std::thread([this, h]() {
            std::ifstream in(filename, std::ios::binary);
            AsyncReadResult res;
            if (in) {
                res.data.assign((std::istreambuf_iterator <char>(in)),
                                std::istreambuf_iterator <char>());
                res.success = true;
            } else {
                res.success = false;
            }
            promise.set_value(res);
            h.resume(); // 这里不需要显式恢复，因为我们使用了 asyncFuture 的机制
        }).detach();
    }

    AsyncReadResult await_resume() { return promise.get_future().get(); }
};

struct AsyncReadTask {
    struct promise_type {
        std::coroutine_handle <promise_type> get_return_object() {
            return std::coroutine_handle <promise_type>::from_promise(*this);
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::terminate(); }
        void return_value(AsyncReadResult value) { result = value; }
        AsyncReadResult result;
    };

    std::coroutine_handle <promise_type> handle;
    AsyncReadResult result;

    AsyncReadTask(std::coroutine_handle <promise_type> h) : handle(h), result(h.promise().result) {}

    ~AsyncReadTask() { if (handle) handle.destroy(); }
};

AsyncReadTask asyncReadFile(const std::string& filename) {
    AsyncReadResult res = co_await AsyncReadAwaitable{filename};
    co_return res;
}

int main() {
    auto task = asyncReadFile("example.txt");
    if (task.result.success) {
        std::cout << "文件内容：" << task.result.data << std::endl;
    } else {
        std::cout << "读取失败" << std::endl;
    }
    return 0;
}

说明

1. AsyncReadAwaitable：包装文件读取逻辑，内部用 std::thread 异步执行。
2. asyncReadFile：使用协程实现的异步读取函数，返回 AsyncReadTask。
3. AsyncReadTask：协程句柄包装器，提供 result 成员供调用者直接访问。

---

四、性能与注意事项

1. 协程本身无开销
   协程在挂起/恢复时不涉及栈复制或线程切换，只是更新内部状态机。真正的开销来自于 awaitable 对象所做的异步操作。

2. 不要滥用
   过度使用协程会导致句柄数目暴增，尤其在高并发网络服务器中，需要对协程池或调度器做细粒度管理。

3. 异常安全
   协程在异常抛出时会走 unhandled_exception()，默认调用 std::terminate。如果需要捕获异常，可在 promise_type::return_void 或 return_value 里进行处理。

---

五、进一步阅读

• 《C++20 标准草案》相关章节
• 《Effective Modern C++》中关于协程的讨论
• 官方实现库如 cppcoro、asio::awaitable 等

---

通过上述介绍，你应该能对 C++20 协程有一个系统的了解，并在实际项目中快速尝试异步编程。协程将成为 C++ 未来异步开发的核心工具，值得每位 C++ 开发者深入掌握。

在多线程 C++ 程序中，线程安全是最关键的设计要点。常见的同步机制主要有两类：原子操作（std::atomic）和互斥锁（std::mutex）。虽然两者都能保证数据的一致性，但在性能、可读性和使用场景上存在显著差异。本文将结合实际代码示例，分析何时使用 std::atomic，何时使用 std::mutex，以及两者如何协同工作。

---

1. 原子操作（std::atomic）

1.1 基本概念

std::atomic 是一种无锁编程工具，提供了对原子类型的线程安全访问。它通过硬件指令实现原子性，避免了传统互斥锁所产生的上下文切换和堆栈拷贝开销。

1.2 常见用例

• 计数器：线程安全地递增/递减
• 标志位：例如停止信号、完成标志
• 交换值：std::atomic::exchange() 用于快速更新

#include <atomic>
#include <thread>
#include <vector>
#include <iostream>

std::atomic <int> counter{0};

void worker() {
    for (int i = 0; i < 10000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::vector<std::thread> workers(8);
    for (auto& t : workers) t = std::thread(worker);
    for (auto& t : workers) t.join();
    std::cout << "Final counter: " << counter.load() << std::endl;
}

1.3 内存序（Memory Order）

• std::memory_order_relaxed：最快，但不保证可见性
• std::memory_order_acquire / std::memory_order_release：常用于生产者-消费者模式
• std::memory_order_seq_cst：默认强序，最安全但成本最高

---

2. 互斥锁（std::mutex）

2.1 基本概念

std::mutex 提供了基于锁的同步机制，确保同一时刻只有一个线程访问受保护的资源。它的实现通常依赖操作系统原语（如 pthread_mutex），并可能涉及上下文切换。

2.2 常见用例

• 复杂数据结构：如 std::vector、std::map 的读写
• 共享资源：文件句柄、网络连接
• 需要批量操作：一次性锁定多变量

#include <mutex>
#include <vector>
#include <thread>
#include <iostream>

std::vector <int> sharedVec;
std::mutex vecMutex;

void addToVector(int val) {
    std::lock_guard<std::mutex> lock(vecMutex);
    sharedVec.push_back(val);
}

int main() {
    std::vector<std::thread> t(4);
    for (int i = 0; i < 4; ++i) {
        t[i] = std::thread([i]{
            for (int j = 0; j < 100; ++j) addToVector(i * 100 + j);
        });
    }
    for (auto& th : t) th.join();
    std::cout << "Vector size: " << sharedVec.size() << std::endl;
}

2.3 std::unique_lock 与 std::scoped_lock

• std::unique_lock 可在同一作用域内多次锁定/解锁
• std::scoped_lock 可一次性锁定多个互斥量，防止死锁

std::mutex m1, m2;
{
    std::scoped_lock lock(m1, m2); // 同时锁定 m1 和 m2
    // ...
}

---

3. 原子 vs 互斥：何时使用哪种

场景	推荐使用
需要极致性能，且操作仅为简单读/写/增/减	std::atomic
操作复杂，需要多变量协同变更	std::mutex
只需读写一个标志或计数器，且多线程并发量大	std::atomic
需要对数据结构做批量修改，或有大量锁竞争	std::mutex
需要保证可见性或顺序（例如生产者-消费者）	结合 memory_order_acquire/release 的 std::atomic 或 std::mutex

关键：如果某个变量只需要单个原子操作（读、写、交换），直接使用 std::atomic 更简洁且性能更佳；若需要在多线程间同步复杂状态或多个相关变量，互斥锁是更安全的选择。

---

4. 混合使用：原子 + 互斥的最佳实践

在实际项目中，往往需要将两者结合使用。例如，使用 std::atomic 控制一个 活动线程数，并使用 std::mutex 保护一个共享队列。

#include <atomic>
#include <mutex>
#include <queue>
#include <thread>
#include <iostream>

std::queue <int> taskQueue;
std::mutex queueMutex;
std::atomic <int> activeThreads{0};

void worker() {
    while (true) {
        int task;
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            if (taskQueue.empty()) break;
            task = taskQueue.front();
            taskQueue.pop();
        }
        // 处理任务
        std::cout << "Thread " << std::this_thread::get_id() << " processing " << task << std::endl;
    }
    activeThreads.fetch_sub(1, std::memory_order_relaxed);
}

int main() {
    // 初始化任务
    for (int i = 0; i < 20; ++i) taskQueue.push(i);
    const int numThreads = 4;
    activeThreads.store(numThreads, std::memory_order_relaxed);
    std::vector<std::thread> workers(numThreads);
    for (int i = 0; i < numThreads; ++i)
        workers[i] = std::thread(worker);
    for (auto& th : workers) th.join();
    std::cout << "All tasks completed. Active threads: " << activeThreads.load() << std::endl;
}

• activeThreads 通过 std::atomic 记录工作线程数量，避免频繁锁定。
• 共享队列 taskQueue 用 std::mutex 保护，保证一次只被一个线程访问。

---

5. 小结

• std::atomic：无锁、低开销，适合简单原子操作（计数器、标志位）。
• std::mutex：传统锁，适合复杂数据结构或需要批量操作的场景。
• 内存序：合理选择 memory_order 能显著提升性能。
• 混合使用：在高并发系统中，两者常结合使用，既保持性能，又保证正确性。

掌握这些同步工具后，你可以根据具体需求，灵活选择最合适的方案，构建既高效又可靠的多线程 C++ 程序。

在 C++17 标准中，<filesystem> 被正式引入为标准库的一部分，为开发者提供了跨平台、类型安全且易于使用的文件系统接口。相比传统的 POSIX API 或第三方库（如 Boost.Filesystem），std::filesystem 在语义、错误处理和性能方面都有显著改进。下面我们从概念、使用场景、典型 API 以及最佳实践四个方面，系统介绍如何在实际项目中高效利用 std::filesystem。

1. 核心概念

组件	作用	备注
path	表示文件系统路径	支持操作符重载，兼容 Windows、Unix
file_status	表示文件状态	file_type 枚举（regular、directory、symlink 等）
directory_iterator / recursive_directory_iterator	迭代器	前者一次目录，后者递归
filesystem_error	异常类型	继承自 std::system_error，携带错误码
error_code	非异常错误处理	通过 std::error_code 可抛出或不抛异常

注意：std::filesystem 的实现依赖于操作系统底层库（如 POSIX stat 或 Windows API），在不同平台上表现一致，但实现细节可能略有差异。

2. 常见使用场景

1. 路径拼接与规范化

   namespace fs = std::filesystem;
   fs::path p = fs::current_path() / "data" / "config.json";
   std::cout << "Canonical: " << fs::canonical(p) << '\n';

2. 文件/目录创建、删除、移动

   fs::create_directory("logs");
   fs::copy_file("a.txt", "b.txt", fs::copy_options::overwrite_existing);
   fs::remove("old.log");

3. 遍历目录

   for (const auto& entry : fs::recursive_directory_iterator("src"))
       std::cout << entry.path() << '\n';

4. 查询文件属性

   auto ftime = fs::last_write_time("config.json");
   auto perms = fs::status("config.json").permissions();

5. 跨平台路径处理
   path::preferred_separator 自动适配不同系统。

3. 典型 API 细节

3.1 路径操作

• operator/：拼接路径。
• lexically_normal()：去除多余的 .、..。
• lexically_relative(const path& base)：相对路径。
• stem()、extension()：获取文件名/扩展名。

3.2 文件系统操作

函数	说明	典型参数
exists()	检查路径是否存在	path
is_regular_file()	是否普通文件	path
is_directory()	是否目录	path
create_directory()	创建单级目录	path
create_directories()	创建多级目录	path
remove()	删除文件/目录	path
remove_all()	递归删除	path
rename()	重命名/移动	path source, path destination
copy_file()	复制文件	path src, path dst, copy_options

3.3 迭代器

• directory_iterator：只遍历当前目录。
• recursive_directory_iterator：递归遍历。
• directory_options::follow_directory_symlink：跟随符号链接。

for (const auto& e : fs::directory_iterator{"./", fs::directory_options::skip_permission_denied})
    std::cout << e.path() << '\n';

4. 错误处理策略

• 异常方式：调用 fs::create_directory("log") 时，若失败会抛出 std::filesystem::filesystem_error。
• 非异常方式：使用 fs::create_directory("log", ec) 或 fs::exists(p, ec)，将错误码写入 std::error_code。
• 推荐做法：在高层业务代码中捕获异常，底层库使用错误码传递错误信息。

std::error_code ec;
fs::create_directory("tmp", ec);
if (ec) {
    std::cerr << "Create failed: " << ec.message() << '\n';
}

5. 性能与实现细节

• std::filesystem 对象（如 path）内部实现采用字符串缓存，避免频繁拷贝。
• canonical() 需要系统调用获取绝对路径，成本相对较高。
• directory_iterator 在 POSIX 下使用 opendir/readdir，在 Windows 使用 FindFirstFileW/FindNextFileW。

小技巧：在需要多次遍历同一目录时，可先将 directory_iterator 转为 std::vector<fs::path>，避免多次系统调用。

6. 结合现代 C++ 编码风格

1. 使用 auto 和 constexpr：

   constexpr auto log_dir = fs::path{"logs"};

2. RAII 资源管理：
   虽然 fs::directory_iterator 本身已实现 RAII，但若自行管理文件句柄时，使用 std::unique_ptr<FILE, decltype(&fclose)> 结合 fopen。
3. 范围 for + 串流：

   for (const auto& entry : fs::recursive_directory_iterator("src"))
       std::cout << entry.path() << '\n';

7. 真实项目案例

7.1 静态资源打包

void package_assets(const fs::path& src, const fs::path& dst) {
    fs::create_directories(dst);
    for (const auto& entry : fs::recursive_directory_iterator(src)) {
        if (!entry.is_regular_file()) continue;
        auto rel = fs::relative(entry.path(), src);
        auto target = dst / rel;
        fs::create_directories(target.parent_path());
        fs::copy_file(entry.path(), target, fs::copy_options::overwrite_existing);
    }
}

7.2 配置文件热重载

class ConfigWatcher {
public:
    ConfigWatcher(const fs::path& file)
        : m_path(file), m_last_time(fs::last_write_time(file)) {}
    bool reload_if_changed() {
        auto now = fs::last_write_time(m_path);
        if (now != m_last_time) {
            m_last_time = now;
            load_config();  // 用户自定义解析
            return true;
        }
        return false;
    }
private:
    fs::path m_path;
    fs::file_time_type m_last_time;
};

8. 常见陷阱与解决方案

陷阱	原因	解决方案
路径字符串拼接导致错误	"/path" + "/sub" 产生 //sub	使用 path / "sub"
Windows 下路径大小写敏感问题	默认不区分大小写	统一使用 lexically_normal 规范化
递归迭代时访问权限被拒	默认会抛异常	directory_options::skip_permission_denied
大文件复制导致内存占用过高	copy_file 逐块写入	通过 copy_file 的 copy_options 控制

9. 未来展望

• C++23 计划进一步完善 std::filesystem，增加更细粒度的权限控制、文件系统监视（fs::file_status 改进）。
• 对于异步文件操作，C++23 也在讨论 std::experimental::filesystem::async，可以配合 std::future 实现非阻塞 IO。

10. 结语

std::filesystem 以其统一、类型安全、异常友好的特性，成为 C++ 开发者处理文件系统任务的首选工具。熟练掌握其 API 并结合现代 C++ 编码规范，能够显著提升项目的可维护性和跨平台兼容性。下一步建议深入阅读官方文档，并在实际项目中逐步替换旧有的 POSIX/Boost 代码，感受 C++ 标准库带来的便利与力量。祝编码愉快！

在多线程环境下实现线程安全的单例模式是一项常见且重要的任务。C++11引入了原子操作和内存序列化，使得实现线程安全的单例变得更为简洁和高效。下面将从理论到实践，介绍几种主流实现方式，并给出示例代码。

1. 静态局部变量（Meyers单例）

C++11规定，局部静态变量的初始化是线程安全的。最简洁的实现方式就是使用静态局部变量：

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;  // C++11保证线程安全
        return instance;
    }

    // 复制构造与赋值运算符禁用
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例接口
    void doSomething() { /* ... */ }

private:
    Singleton() = default;
    ~Singleton() = default;
};

优点：

• 简单、易读
• 编译器自动处理线程同步

缺点：

• 如果在程序初始化时需要对单例进行延迟初始化，或者需要在单例销毁前执行特定操作，可能会遇到“static initialization order fiasco”。

2. 带双重检查锁（Double-Check Locking）

在某些旧编译器或需要显式控制初始化时，可使用双重检查锁实现线程安全单例：

class Singleton {
public:
    static Singleton* instance() {
        Singleton* tmp = instance_.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            tmp = instance_.load(std::memory_order_relaxed);
            if (!tmp) {
                tmp = new Singleton();
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }

    // 禁用拷贝
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
    ~Singleton() = default;

    static std::atomic<Singleton*> instance_;
    static std::mutex mutex_;
};

std::atomic<Singleton*> Singleton::instance_{nullptr};
std::mutex Singleton::mutex_;

优点：

• 延迟初始化
• 对早期 C++ 标准兼容

缺点：

• 代码较繁琐
• 需要手动处理原子与锁，容易出现错误

3. 利用 std::call_once

std::call_once 通过内部锁确保一次性初始化，既简单又可靠：

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(initFlag_, [](){
            instance_ = new Singleton();
        });
        return *instance_;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
    ~Singleton() = default;

    static Singleton* instance_;
    static std::once_flag initFlag_;
};

Singleton* Singleton::instance_ = nullptr;
std::once_flag Singleton::initFlag_;

优点：

• 语义清晰
• 兼容所有 C++11 及以上编译器

缺点：

• 需要手动管理指针，容易忘记释放

4. 线程安全的懒加载容器

如果你想在多线程环境下懒加载资源，同时保证单例唯一，可以将单例包装在一个 std::shared_ptr 或 std::unique_ptr 中，配合 std::call_once：

class Singleton {
public:
    static std::shared_ptr <Singleton> instance() {
        std::call_once(initFlag_, [](){
            instance_ = std::make_shared <Singleton>();
        });
        return instance_;
    }

    // ...

private:
    Singleton() = default;
    ~Singleton() = default;

    static std::shared_ptr <Singleton> instance_;
    static std::once_flag initFlag_;
};

std::shared_ptr <Singleton> Singleton::instance_ = nullptr;
std::once_flag Singleton::initFlag_;

5. 需要注意的细节

1. 析构顺序
   如果单例在程序退出前需要执行清理工作，最好使用 std::shared_ptr 或在 instance() 返回前注册 std::atexit 清理函数，避免静态对象的销毁顺序导致访问已释放资源。

2. 多次实例化
   在使用 dll 或插件机制时，若每个模块都有自己的全局静态变量，可能会出现多份单例。解决方案是将单例实现为线程本地存储（TLS）或使用进程级别的同步机制。

3. 性能考量
   std::call_once 只在第一次调用时加锁，其余调用几乎无开销。相比双重检查锁，它更简单且同样高效。

6. 小结

• 最推荐：使用静态局部变量（Meyers单例）或 std::call_once，两者都符合 C++11 标准，线程安全且代码简洁。
• 特殊需求：若需要显式控制初始化顺序或在特定时刻销毁，考虑 std::call_once + std::unique_ptr 或 std::shared_ptr。
• 旧编译器：若只能使用 C++03，双重检查锁仍然可行，但要注意编译器的内存模型支持。

通过上述方案，你可以在 C++ 项目中轻松实现线程安全的单例模式，避免多线程竞争导致的未知错误。

在 C++17 及其之后的标准中，constexpr 作为一种关键字被广泛用于编译期计算。然而，consteval 作为 C++20 的新关键字也被引入，专门用于要求表达式在编译期求值。本文将对两者进行对比，阐明它们的差异，并探讨在实际项目中如何合理选择使用。

---

1. constexpr 的基本语义

• 编译期或运行期
  constexpr 修饰的函数或变量可以在编译期求值，也可以在运行期求值。只要满足编译期求值的条件，编译器会尝试在编译时执行，从而生成常量；如果编译期无法求值，则在运行时使用。
• 约束
  constexpr 函数必须满足以下条件：
  1. 函数体只能包含单个 return 语句（C++17 限制已放宽）。
  2. 只能使用 constexpr 变量、函数和对象。
  3. 参数类型必须是 literal type。
• 典型用途
  • 预先计算数学常量（如三角函数、阶乘等）。
  • 在容器、数组初始化时提供编译期常量。
  • 用于 static_assert、template 参数等场景。

2. consteval 的引入动机

consteval 关键字专门用于强制编译期求值。它解决了 constexpr 不能保证编译期求值的不足：

• 强制性
  若一个函数被标记为 consteval，调用它的表达式 必须 在编译期求值。若无法在编译期求值，编译器将报错。
• 更严格的约束
  consteval 函数不能包含不支持编译期执行的语句（如 I/O、动态分配等）。
• 适配度
  只适用于那些必须在编译期得到结果、且结果在运行期不需要改变的场景。

3. 关键差异对照表

维度	constexpr	consteval
是否强制编译期求值	否	是
语义范围	函数、变量、对象	函数
允许运行期使用	可以	不可以
错误处理	失败时退回运行期	直接报错
用途	兼容编译期和运行期	仅编译期，保证结果不可变

4. 应用场景举例

4.1 需要编译期求值的数学函数

consteval int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int fac5 = factorial(5);  // OK
    // constexpr int facN = factorial(N); // N 是变量，错误：必须在编译期确定
}

4.2 运行期需要的“可配置”常量

constexpr int maxSize(int mode) {
    return mode == 0 ? 128 : 256;   // 可根据编译时参数决定
}

此处使用 constexpr 而非 consteval，因为 mode 可能在运行期确定。

4.3 结合 static_assert 的编译期校验

consteval bool checkPrime(int n) {
    for (int i = 2; i * i <= n; ++i)
        if (n % i == 0) return false;
    return n > 1;
}

static_assert(checkPrime(13), "13 不是素数");

5. 性能与可维护性

• 性能
  consteval 的强制性使得编译器在编译阶段就完成所有计算，避免运行期开销。
• 可维护性
  代码更易理解：标记为 consteval 的函数显然是“只在编译期使用”的，减少误用。
• 错误定位
  consteval 提供更明确的错误信息，方便开发者快速定位编译期求值失败的原因。

6. 结语

• 当你需要一个函数在 任何调用上下文 下都能在编译期求值，并且想要编译器强制执行时，使用 consteval。
• 若你需要兼容 编译期与运行期，或者想让编译器在必要时回退到运行期，constexpr 是更合适的选择。

在实际项目中，合理划分两者可以提高代码的可读性、可维护性以及性能表现。始终记住：“强制即限制，灵活即开放。”

在 C++17 之前，实现多态的方式大多依赖虚函数、继承层次结构或手工实现类型擦除。随着 std::variant 的加入，程序员可以在编译时对可能出现的几种类型进行列举，既避免了指针与动态分配，又能在运行时安全地访问正确的成员。本文从 std::variant 的基本语法、访问机制、实用技巧以及常见坑点四个方面，系统阐述如何在实际项目中运用该类型。

---

1. 基本语法与初始化

#include <variant>
#include <string>
#include <iostream>

using Value = std::variant<int, double, std::string>;

int main() {
    Value v = 42;                // 直接用 int 初始化
    v = std::string("hello");    // 也可以用 std::string
    std::cout << std::get<int>(v) << '\n';  // 访问 int
}

• 类型列表：std::variant 只能接受不包含 std::monostate 的类型列表。若需要空状态，显式加入 std::monostate。
• 初始化：使用任何列表中的类型构造 std::variant。编译器会自动推导。
• 默认构造：如果列表中包含 std::monostate，默认构造将得到该值；否则需要手动初始化。

---

2. 访问方式

方法	说明	示例
`std::get
(v)| 如果当前活跃成员不是T，抛出std::bad_variant_access|std::cout << std::get(v);`
`std::get_if
(&v)| 返回指针，若不是T则返回nullptr|if (auto p = std::get_if(&v)) std::cout << *p;`
std::visit	访问活跃成员，传递一个可调用对象	std::visit([](auto&& arg){ std::cout << arg; }, v);
index()	返回活跃成员索引	std::cout << v.index();

小技巧：在 std::visit 的 lambda 里使用模板参数（auto&&）可以让代码更加简洁。

---

3. 与 std::optional 的组合使用

在某些业务场景下，可能既需要多种类型，又需要“无值”状态。此时可以用 std::optional<std::variant<...>>：

std::optional <Value> opt;
if (someCondition) {
    opt = Value(3.14);  // 存储 double
}
if (opt) {
    std::visit([](auto&& val){ std::cout << val; }, *opt);
}

• 通过 has_value() 或 operator bool() 判断是否存在值。
• 需要注意的是 std::variant 本身也可以存放 std::monostate，但与 std::optional 组合能更直观地表达“无值”概念。

---

4. 常见坑点与最佳实践

1. 索引误用
   index() 只在你事先知道活跃类型序号时有意义，且序号从 0 开始。错误的索引会导致逻辑错误。

2. 性能关注
   std::visit 对每次访问都会产生一次分支跳转，若访问频繁可考虑使用 std::get_if 或直接 std::get（若已知类型）。
   对比：std::get 在类型不匹配时会抛异常，开销略大。

3. 复制/移动语义
   std::variant 对内部类型使用的是 T::T(const T&) 或 T::T(T&&)。若内部类型不可移动，可能导致性能下降。
   解决办法：为类型显式提供移动构造或使用 std::move。

4. 递归类型
   std::variant 不能包含自身类型；若需要递归结构，使用 std::shared_ptr 或 std::unique_ptr 包装再放进 variant。

5. 类型歧义
   若列表中存在同名但不同参数列表的重载函数，std::get 会报错。此时需要用 std::variant_alternative<Index, Variant>::type 明确指定。

---

5. 实战案例：实现一个简易的“值”对象

#include <variant>
#include <vector>
#include <iostream>
#include <iomanip>

using Value = std::variant<int, double, std::string>;

class Cell {
    Value data_;
public:
    Cell(Value v) : data_(std::move(v)) {}

    template<typename T>
    T get() const { return std::get <T>(data_); }

    void print() const {
        std::visit([](auto&& val){
            if constexpr (std::is_same_v<decltype(val), std::string>)
                std::cout << std::setw(10) << val;
            else
                std::cout << std::setw(10) << val;
        }, data_);
    }
};

int main() {
    std::vector <Cell> table {
        Cell(1), Cell(3.14), Cell("C++")
    };

    for (const auto& cell : table)
        cell.print();
}

此类既能存储多种类型，又保证在访问时的类型安全。使用 std::visit 可以灵活处理不同类型的输出，而 std::get 可以在已知类型时快速检索。

---

6. 结语

std::variant 为 C++ 语言提供了一种强类型、多态的数据容器，既避免了裸指针与运行时类型检查，又保持了编译时的安全性与高效性。只要掌握好它的访问机制与常见陷阱，便能在各种业务场景中实现更简洁、可维护的代码。希望本文能为你在日常编码中更好地利用 std::variant 提供实用参考。

在 C++20 之前，constexpr 函数的能力已经大幅提升，但它们仍然有一些严格的限制。随着 C++20 的发布，constexpr 函数获得了更高的灵活性和性能优势，成为编译期和运行期计算的桥梁。本文将深入探讨 C++20 constexpr 函数的新特性、常见用例以及最佳实践，帮助你充分利用这一强大工具。

1. constexpr 的演进

1.1 早期 constexpr（C++11–C++14）

• C++11：只能包含返回字面量的表达式、单一 return 语句、对全局变量的读写有限制。
• C++14：允许循环、if 语句、异常处理，但仍不支持全局写、new/delete、静态变量等。

1.2 C++17 里程碑

• 支持 try/catch、constexpr 变量初始化的更复杂表达式。
• 允许在 constexpr 函数内部声明 static 变量，但只能读写。

1.3 C++20 的大步跨越

• 完全可变：可以在 constexpr 函数中执行 new/delete，操作动态内存。
• 静态变量：static 变量可以被修改，且在多次调用中保持状态。
• 协程：constexpr 函数可以与 co_yield、co_return 协同工作。
• 模板参数推断：更强大的模板元编程支持。

2. 典型用例

2.1 预计算多项式系数

constexpr double poly(double x) {
    return ((3.0 * x + 2.0) * x - 5.0) * x + 1.0;
}

int main() {
    constexpr double result = poly(2.5);
    static_assert(result == 23.375, "Unexpected value");
}

这里，poly 在编译期计算，减少运行时负担。

2.2 生成运行时可变状态的对象

constexpr std::string_view make_prefix() {
    static std::string prefix = "Log: ";
    return prefix;
}

static std::string prefix 可以在 constexpr 函数中被修改，例如在程序启动阶段动态构造日志前缀。

2.3 constexpr 协程生成序列

#include <coroutine>
#include <iostream>

template<typename T>
struct Generator {
    struct promise_type;
    using handle_type = std::coroutine_handle <promise_type>;
    struct promise_type {
        T value_;
        Generator get_return_object() { return {handle_type::from_promise(*this)}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::terminate(); }
        template<typename U>
        std::suspend_always yield_value(U&& v) {
            value_ = std::forward <U>(v);
            return {};
        }
        void return_void() {}
    };
    handle_type handle_;
    explicit Generator(handle_type h) : handle_(h) {}
    ~Generator() { handle_.destroy(); }
    T next() { handle_.resume(); return handle_.promise().value_; }
};

constexpr Generator <int> range(int start, int end) {
    for (int i = start; i <= end; ++i)
        co_yield i;
}

在 C++20 编译期内，你可以使用此协程生成固定范围的整数序列，既不需要动态内存也能保证类型安全。

3. 性能评估

3.1 编译期 vs 运行期

• 编译期计算：constexpr 的主要优势是将复杂计算移到编译阶段，减少运行时 CPU 周期。适用于配置数据、数学常数表、预计算路径等。
• 运行期动态：在 constexpr 函数中使用 new/delete 时，若不在编译期可确定对象大小，编译器可能会产生运行时开销。但在需要动态内存但仍想保持 constexpr 语义时，它提供了灵活性。

3.2 典型基准

• 例子：在一个包含 10,000 个点的三角形剖分算法中，使用 constexpr 预生成顶点坐标表可将 CPU 时间从 150ms 降到 10ms（编译期计算占用 ~5ms，但显著减少了运行时循环）。

4. 常见陷阱

1. 循环计数不确定：如果循环的迭代次数无法在编译期确定，编译器将把它放到运行时。
2. 递归深度：递归 constexpr 函数在编译期可能导致堆栈溢出，需限制递归深度或使用迭代方式。
3. 异常抛出：虽然 C++20 允许在 constexpr 中使用 try/catch，但抛出异常会导致编译失败，除非异常在 constexpr 评估中被捕获并处理。

5. 最佳实践

场景	推荐做法
需要预计算常量	直接使用 constexpr 表达式或函数
需要动态内存但保持 constexpr 语义	在 C++20 内使用 new/delete，但注意对象生命周期
需要协程式生成序列	使用 co_yield 与 Generator 结构体
大量递归	尽量改为迭代或使用模板元编程

6. 结语

C++20 的 constexpr 函数已从“只能在编译期做有限计算”演进为“一种能够在编译期与运行期之间无缝切换的强大工具”。掌握其新特性并合理运用，可以显著提升程序性能、可维护性和表达力。无论你是嵌入式开发、游戏编程还是高性能计算，理解并使用 C++20 constexpr 将为你的项目带来新的可能性。

1. 精准限定类型
   利用 requires 子句和 concept 直接描述期望的类型属性，例如 std::integral 或自定义 CopyConstructible。这样编译器在模板实例化时可以更快判断可行性，避免产生长错误信息。

   template <typename T>
   requires std::integral <T>
   T add(T a, T b) { return a + b; }

2. 重构泛型算法
   将通用算法拆分成多重概念，每个概念承担单一职责。这样可以让用户在实现类时只需要满足相应概念，而不是全部。

   template <typename Iterator>
   concept ForwardIterator = requires(Iterator it) {
       { *it } -> std::same_as<typename Iterator::value_type&>;
       ++it;
   };

3. 使用 std::concepts::borrowed_reference
   当你需要返回引用但不确定其生命周期时，使用 borrowed_reference 约束可以让编译器确认引用的安全性。

   template <typename T>
   concept BorrowedRef = std::is_reference_v <T> &&
                         std::same_as<std::remove_reference_t<T>, std::string>;

4. 与 constexpr 结合
   在概念中使用 constexpr 函数进行复杂判断，可在编译期完成计算，进一步提升编译速度。

   constexpr bool is_power_of_two(std::size_t n) {
       return n && ((n & (n - 1)) == 0);
   }
   template <std::size_t N>
   concept PowerOfTwo = is_power_of_two(N);

5. 自动文档化
   通过在概念声明中加入 [[nodiscard]] 或 [[deprecated]] 等属性，让 IDE 在提示错误时给出更明确的上下文，提升代码可读性。

   template <typename T>
   concept Deprecated = requires(T t) { t.deprecated(); };

通过上述技巧，你可以在 C++20 的概念体系下编写既安全又高效的模板代码，同时让编译器在类型检查时发挥更大作用。