standrad c++

协程是 C++20 新增的语言特性，允许我们以“暂停和恢复”的方式编写异步代码，从而使代码更加顺序化、易读且高效。本文将带你快速掌握协程的核心概念，并演示如何利用它实现一个简易的异步文件读取器。

1. 协程基础

协程在 C++ 中由 co_await、co_yield、co_return 三个关键字实现。它们对应的功能分别是：

• co_await：等待一个可等待对象（awaitable）的完成，并在完成后继续执行。
• co_yield：生成一个值并暂停协程，等待下一个 co_yield 或 co_return。
• co_return：结束协程，并返回最终结果。

要声明一个协程函数，需要返回一个“协程类型”。最常见的两种协程类型是：

• `std::future `：传统的异步结果容器，兼容 “ 库。
• `std::generator `（来自 “ 或第三方实现）：返回可迭代的值序列。

2. Awaitable 对象

协程需要等待的对象必须满足 Awaitable 协议，即拥有 await_ready()、await_suspend() 和 await_resume() 成员函数。标准库提供了一些常用的 Awaitable，例如：

• `std::future ` 的 `co_await` 会在 future 完成时恢复协程。
• std::experimental::coroutine_handle：低层次的协程句柄，可用于自定义 Awaitable。

3. 简易异步文件读取

下面演示如何用协程实现一个异步文件读取器。我们使用标准库的 `

` 读取文件，并用 `std::async` 与 `co_await` 配合模拟异步行为。 “`cpp #include #include #include #include #include #include #include #include namespace async_file { struct AwaitableRead { std::ifstream& stream; std::string buffer; std::size_t bytes_to_read; bool await_ready() { return false; } // 总是需要挂起 void await_suspend(std::coroutine_handle h) { std::thread([=]() mutable { // 模拟 I/O 延迟 std::this_thread::sleep_for(std::chrono::milliseconds(100)); buffer.resize(bytes_to_read); stream.read(buffer.data(), bytes_to_read); h.resume(); // 恢复协程 }).detach(); } std::string await_resume() { return buffer; } }; template struct AwaitableFuture { std::future fut; AwaitableFuture(std::future f) : fut(std::move(f)) {} bool await_ready() const noexcept { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; } void await_suspend(std::coroutine_handle h) { std::thread([=]() mutable { fut.wait(); h.resume(); }).detach(); } T await_resume() { return fut.get(); } }; } // namespace async_file // 协程函数：读取文件并返回内容 auto async_read_file(const std::string& path, std::size_t chunk_size = 1024) -> std::future { std::ifstream file(path, std::ios::binary); if (!file) throw std::runtime_error(“Cannot open file”); std::string content; while (file.peek() != EOF) { async_file::AwaitableRead ar{file, “”, chunk_size}; std::string chunk = co_await ar; content += chunk; } co_return content; } int main() { try { auto fut = async_read_file(“sample.txt”); // 在主线程可以做其他工作 std::cout << "Reading file asynchronously…\n"; std::string data = fut.get(); // 阻塞直到文件读取完成 std::cout << "File size: " << data.size() << " bytes\n"; } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << '\n'; } } “` ### 关键点说明 1. **AwaitableRead** – `await_ready()` 总返回 `false`，表示协程始终挂起。 – `await_suspend()` 在独立线程中执行文件读取，完成后调用 `h.resume()` 重新调度协程。 – `await_resume()` 返回读取到的缓冲区。 2. **async_read_file** – 通过 `co_await` 等待 `AwaitableRead` 的完成，将每次读取的块追加到 `content`。 – 最终用 `co_return` 返回完整文件内容。 3. **异步等待** – `std::future` 作为协程返回类型，调用者可以在 `fut.get()` 时等待协程完成，或者使用 `co_await` 在另一个协程中等待。 ## 4. 性能与局限 – **线程数**：上述实现为每个 I/O 操作创建一个线程，适合 I/O 密集型但线程数不多的场景。生产环境建议使用线程池或异步 I/O API（如 `io_uring`、`Boost.Asio`）来替代。 – **错误处理**：在协程内部抛出的异常会自动传递到返回的 `std::future`，在 `get()` 时会抛出。 – **编译器支持**：C++20 协程已在 GCC 10、Clang 12 及 MSVC 19.28 开始支持，但不同编译器的实现细节略有差异，建议使用 `-fcoroutines` 或相应标志。 ## 5. 进一步阅读 – 《C++20 协程深度剖析》 – 《Boost.Asio 与 C++20 协程的结合》 – 《现代 C++：使用 std::generator 进行流式数据处理》 通过本例，你可以看到协程让异步编程变得像同步一样直观。掌握了协程后，可以将其应用到网络请求、数据库查询、文件系统操作等多种 I/O 场景，从而显著提升代码可读性与维护性。

在多线程环境下，确保单例对象只被创建一次并且可以安全地被所有线程访问是一项常见需求。下面以 C++17 为例，演示几种常用的线程安全单例实现方式，并讨论它们各自的优缺点。

---

1. C++11 之静态局部变量（Meyers 单例）

class Singleton {
public:
    static Singleton& instance() {
        static Singleton inst;   // C++11 guarantees thread-safe initialization
        return inst;
    }
    // 其他业务接口
private:
    Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

原理

C++11 对局部静态变量的初始化进行了同步，保证了多线程下第一次进入 instance() 时的构造只会执行一次。后续访问直接返回已构造的对象。

优点

• 实现简单：无须手动管理锁或原子操作。
• 高效：构造后访问不需要额外同步。
• 安全：构造函数可以抛异常，标准会自动处理。

缺点

• 无法延迟销毁：对象在程序退出时才销毁，若需要显式销毁需手动实现。
• 不支持按需初始化参数：构造时无法传参。

---

2. 经典双重检查锁（双重检查锁定）

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance_ == nullptr) {                     // 1. First check
            std::lock_guard<std::mutex> lock(mutex_);
            if (instance_ == nullptr) {                 // 2. Second check
                instance_ = new Singleton();
            }
        }
        return instance_;
    }
    static void destroy() {
        std::lock_guard<std::mutex> lock(mutex_);
        delete instance_;
        instance_ = nullptr;
    }
private:
    Singleton() = default;
    static Singleton* instance_;
    static std::mutex mutex_;
};

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mutex_;

原理

• 第一次检查可避免每次访问都加锁。
• 第二次检查保证在多线程竞争下只有一个线程真正创建实例。

优点

• 延迟销毁：可在需要时手动销毁实例。
• 可传参：构造时可以使用额外参数。

缺点

• 易出错：需要正确使用 std::atomic 或 memory_order 以避免重排问题。
• 性能略低：每次访问仍需一次无锁检查，且在第一次创建时会锁定。

---

3. std::call_once 与 std::once_flag

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(flag_, []{ instance_ = new Singleton(); });
        return *instance_;
    }
    static void destroy() {
        delete instance_;
        instance_ = nullptr;
    }
private:
    Singleton() = default;
    static Singleton* instance_;
    static std::once_flag flag_;
};

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

原理

std::call_once 保证指定的 lambda 只会被调用一次，即使在并发环境下。此方法在 C++11 之后被官方推荐为线程安全单例的实现方式。

优点

• 实现简洁：无需手动管理锁。
• 性能好：仅在第一次调用时有同步开销，随后访问无锁。

缺点

• 同样无法传参：构造时参数无法传递。
• 销毁手动：需要显式调用 destroy()。

---

4. 智能指针 + 原子

如果你想在单例销毁时更加安全，结合 std::shared_ptr 与 std::atomic 可以实现：

class Singleton {
public:
    static std::shared_ptr <Singleton> getInstance() {
        std::shared_ptr <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 = std::shared_ptr <Singleton>(new Singleton());
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }
private:
    Singleton() = default;
    static std::atomic<std::shared_ptr<Singleton>> instance_;
    static std::mutex mutex_;
};

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

说明

• 通过 std::shared_ptr 自动管理生命周期，避免显式销毁。
• 使用原子操作保证指针的可见性。

适用场景

当单例对象需要被多处持有，并且销毁时不想出现悬空指针时，这种方式更为合适。

---

5. 何时选择哪种实现？

场景	推荐实现	说明
简单单例，生命周期与程序一致	Meyers 单例	代码最简洁
需要显式销毁或传参	双重检查锁 / std::call_once	兼顾灵活性
多线程安全、性能优先	std::call_once	C++11 官方推荐
需要共享生命周期	std::shared_ptr + 原子	自动销毁、避免悬空

---

6. 代码示例：线程安全配置文件读取器

下面给出一个实际项目中常见的单例：配置文件读取器。

#include <fstream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <mutex>
#include <memory>

class Config {
public:
    static Config& instance(const std::string& path = "config.ini") {
        static std::once_flag flag;
        static std::unique_ptr <Config> instance;
        std::call_once(flag, [&]{
            instance.reset(new Config(path));
        });
        return *instance;
    }

    std::string get(const std::string& key, const std::string& default_val = "") const {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = data_.find(key);
        return it != data_.end() ? it->second : default_val;
    }

private:
    Config(const std::string& path) {
        std::ifstream file(path);
        std::string line;
        while (std::getline(file, line)) {
            if (line.empty() || line[0] == '#') continue;
            std::istringstream iss(line);
            std::string key, eq, value;
            if (iss >> key >> eq >> value && eq == "=") {
                data_[key] = value;
            }
        }
    }
    std::unordered_map<std::string, std::string> data_;
    mutable std::mutex mutex_;
};

• 使用方式：

auto& cfg = Config::instance();            // 默认读取 config.ini
auto dbHost = cfg.get("db_host", "localhost");

• 优点：只在第一次访问时读取文件，后续访问无锁（只对读取操作加锁）。

---

7. 小结

• C++11 已经提供了可靠的单例实现方式，推荐使用 static 局部变量或 std::call_once。
• 若需要 显式销毁 或 传参，可考虑双重检查锁或自定义 std::once_flag。
• 对于 复杂生命周期 的对象，结合 std::shared_ptr 与原子可以更安全。
• 最终选择应根据项目需求、性能要求和代码可维护性综合决定。

祝你在 C++ 单例实现上顺利，代码简洁又安全！

在现代 C++ 中，std::variant 成为一种强大且类型安全的替代传统 void* 或 union 的工具。它允许你在单个对象中存放多种类型中的一种，并在运行时通过访问器（std::get, std::visit 等）进行安全访问。下面将通过一个具体示例，演示如何利用 std::variant 构建一个简易的“多态容器”，并讨论其优点与使用注意事项。

---

1. 背景与需求

传统面向对象编程往往通过继承和虚函数实现多态，但在某些场景（如性能敏感、跨平台或非类类型）下，虚函数表（vtable）带来的开销和限制可能不太理想。C++17 引入的 std::variant 为此提供了一种轻量级、类型安全的方案。

我们需要实现一个容器 ShapeContainer，可以存放 Circle, Rectangle, Triangle 三种形状，并且能够对存放的形状执行对应的计算（面积、周长等），而无需依赖继承。

---

2. 代码实现

#include <iostream>
#include <variant>
#include <cmath>
#include <string>
#include <vector>
#include <optional>

// 形状结构体
struct Circle {
    double radius;
};

struct Rectangle {
    double width, height;
};

struct Triangle {
    double a, b, c; // 三边长
};

// 计算圆面积
double area(const Circle& c) { return M_PI * c.radius * c.radius; }
double perimeter(const Circle& c) { return 2 * M_PI * c.radius; }

// 计算矩形面积
double area(const Rectangle& r) { return r.width * r.height; }
double perimeter(const Rectangle& r) { return 2 * (r.width + r.height); }

// 计算三角形面积（海伦公式）
double area(const Triangle& t) {
    double s = (t.a + t.b + t.c) / 2.0;
    return std::sqrt(s * (s - t.a) * (s - t.b) * (s - t.c));
}
double perimeter(const Triangle& t) { return t.a + t.b + t.c; }

// 定义 variant
using Shape = std::variant<Circle, Rectangle, Triangle>;

// 访问器函数
std::optional <double> shape_area(const Shape& s) {
    return std::visit([](auto&& arg) -> double {
        return area(arg);
    }, s);
}

std::optional <double> shape_perimeter(const Shape& s) {
    return std::visit([](auto&& arg) -> double {
        return perimeter(arg);
    }, s);
}

// 简易容器
class ShapeContainer {
public:
    void add(const Shape& shape) { shapes_.push_back(shape); }

    void print_all() const {
        for (size_t i = 0; i < shapes_.size(); ++i) {
            std::cout << "Shape #" << i << ":\n";
            std::visit([&](auto&& arg) {
                using T = std::decay_t<decltype(arg)>;
                if constexpr (std::is_same_v<T, Circle>) {
                    std::cout << "  Type: Circle, radius=" << arg.radius << "\n";
                } else if constexpr (std::is_same_v<T, Rectangle>) {
                    std::cout << "  Type: Rectangle, w=" << arg.width << ", h=" << arg.height << "\n";
                } else if constexpr (std::is_same_v<T, Triangle>) {
                    std::cout << "  Type: Triangle, a=" << arg.a << ", b=" << arg.b << ", c=" << arg.c << "\n";
                }
                std::cout << "  Area: " << shape_area(shapes_[i]).value_or(0.0) << "\n";
                std::cout << "  Perimeter: " << shape_perimeter(shapes_[i]).value_or(0.0) << "\n";
            }, shapes_[i]);
        }
    }

private:
    std::vector <Shape> shapes_;
};

int main() {
    ShapeContainer sc;
    sc.add(Circle{5.0});
    sc.add(Rectangle{4.0, 3.0});
    sc.add(Triangle{3.0, 4.0, 5.0});
    sc.print_all();
    return 0;
}

关键点说明

1. 类型安全：std::variant 的内部维护了类型信息，访问时不需要强制转换，编译器能检查类型匹配。
2. 性能：std::variant 在多数实现中采用了小型对象优化（SBO），避免了堆分配。访问器 std::visit 通过模式匹配实现，在大多数情况下与传统虚函数调用相当甚至更快。
3. 可组合：你可以用 std::variant 与其他 STL 容器无缝组合（如上例的 `std::vector `）。

---

3. 使用场景与局限

场景	适用性	说明
需要在运行时选择多种具体实现	✔	std::variant 适合有限的、已知类型集合
需要继承多态（动态类型绑定）	❌	若类型列表可能无限扩展，或需要在运行时新增类型，传统继承更灵活
性能极端敏感（需要手动布局）	❌	在极端低延迟或嵌入式场景，手写联合和分支可能更优

---

4. 小技巧

• 自定义 std::visit 变体：如果你需要为 variant 自动生成多个访问器（如 area, perimeter），可以用宏或模板元编程来减少重复代码。
• 错误处理：如果访问错误类型时想抛异常，可使用 `std::get (variant)` 或 `std::get_if`。
• 多语言互操作：当需要把 variant 传递给 C 语言接口时，可将其拆成 enum + union 结构，保持 ABI 兼容。

---

5. 小结

std::variant 在 C++17 之后成为处理“有限多态”问题的首选工具。它兼具类型安全、易用性与高性能，适用于大多数需要在同一容器中存放不同类型数据的场景。通过本文示例，你可以快速上手并将 variant 集成到自己的项目中，替代传统虚表模式，实现更高效、可维护的代码架构。

在 C++ 发展的历程中，模板元编程（Template Metaprogramming，TMP）一直是编译期计算的核心技术。早期的 TMP 主要依赖于 SFINAE（Substitution Failure Is Not An Error）技巧，借助 std::enable_if、std::conditional、std::integral_constant 等工具进行类型筛选与条件编译。随着 C++20 及其后续标准引入的概念（Concepts），TMP 迈向了更为语义化、可读性更强的时代。本文将回顾 SFINAE 与概念的区别，并给出一份完整的实战案例，展示如何在现代 C++ 代码中利用 TMP 实现“可排序容器”的编译期约束。

1. SFINAE 时代的 TMP

SFINAE 的核心思想是：在模板参数替换过程中，如果产生错误则不导致编译失败，而是从候选列表中移除该模板实例。典型实现方式如下：

template<typename T>
using has_value_type = typename T::value_type;

template<typename T, typename = void>
struct is_container : std::false_type {};

template<typename T>
struct is_container<T, std::void_t<has_value_type<T>>> : std::true_type {};

这里我们通过 std::void_t 把成功的替换映射为 void，若 T 没有 value_type 成员则替换失败，is_container 将默认 false_type。然而，SFINAE 的代码往往难以阅读，错误信息也不友好。

2. 概念（Concepts）登场

C++20 引入了概念，它是一种对类型约束的语义化表达方式。相比 SFINAE，概念更易读、错误信息更直观。上述例子可改写为：

template<typename T>
concept Container = requires(T t) {
    typename T::value_type;
};

template<Container T>
struct MyContainer { /* ... */ };

概念可以直接在模板参数列表中使用，也可以在函数返回类型、lambda 捕获等位置出现。它们让编译器能够在类型匹配阶段直接拒绝不符合约束的实例。

3. 现代 TMP：实现“可排序容器”

下面给出一个完整的例子：定义一个 SortableContainer 概念，要求容器具备以下属性：

1. 具有 value_type 并且 value_type 本身可比较（支持 < 操作符）。
2. 提供 begin() 与 end() 成员或相应的非成员函数。
3. 可以通过 std::sort 对其元素进行排序。

随后实现一个泛型 sort_container 函数，能够在编译期检查这些约束。

#include <algorithm>
#include <concepts>
#include <vector>
#include <list>
#include <deque>
#include <iostream>

// 1. 判断类型是否可比较
template<typename T>
concept Comparable = requires(T a, T b) {
    { a < b } -> std::convertible_to<bool>;
};

// 2. 判断容器是否提供 begin() 与 end()
template<typename T>
concept HasBeginEnd = requires(T t) {
    { t.begin() } -> std::input_iterator;
    { t.end() }   -> std::input_iterator;
};

// 3. 判断容器元素类型是否可比较
template<typename T>
concept SortableContainer = requires(T t) {
    typename T::value_type;
    requires Comparable<T::value_type>;
} && HasBeginEnd <T>;

// 4. 泛型排序函数
template<SortableContainer C>
void sort_container(C& container) {
    std::sort(container.begin(), container.end());
}

// 5. 示例使用
int main() {
    std::vector <int> vec = {3, 1, 4, 1, 5};
    sort_container(vec);
    for (auto v : vec) std::cout << v << ' ';
    std::cout << '\n';

    std::list <int> lst = {9, 8, 7};
    sort_container(lst);  // 错误：list 不是随机访问迭代器
}

3.1 代码说明

• Comparable 概念检查类型是否支持 < 运算符并返回布尔值。若 T 为自定义类型，只需实现 < 即可。
• HasBeginEnd 确认容器提供可用的 begin() 与 end()。这里使用 std::input_iterator 检测返回类型是否为迭代器，保证兼容性。
• SortableContainer 组合了前两者，并且强制 value_type 必须可比较。
• sort_container 在编译期对容器实例进行约束检查，若不满足 SortableContainer，编译器会报错，指出是哪一项约束失败。

3.2 兼容随机访问容器

std::sort 只支持随机访问迭代器。上述示例中 std::list 会触发编译错误，因为其迭代器不满足 std::random_access_iterator_tag。可以通过修改 HasBeginEnd 或使用 std::is_sorted 之类的检查来进一步细化约束。

4. 与传统 SFINAE 对比

以下展示了同样功能的 SFINAE 版本，供对比参考：

template<typename, typename = void>
struct is_sortable_container : std::false_type {};

template<typename T>
struct is_sortable_container<T,
    std::void_t<
        typename T::value_type,
        std::enable_if_t<std::is_convertible_v<
            decltype(std::declval<T::value_type>() < std::declval<T::value_type>()),
            bool>>,
        std::enable_if_t<
            std::is_same_v<
                decltype(std::declval <T>().begin()),
                decltype(std::declval <T>().end())>
        >
    >> : std::true_type {};

template<typename C>
void sort_container_sfin(C& c) {
    static_assert(is_sortable_container <C>::value, "C must be a sortable container");
    std::sort(c.begin(), c.end());
}

SFINAE 版本代码更长、更晦涩，错误信息不如概念清晰。概念不仅使代码更简洁，也更易维护。

5. 结语

随着 C++20 及未来标准的发布，模板元编程正经历从“技巧”向“规范”的转变。概念为我们提供了强大的类型约束工具，使得 TMP 代码既安全又可读。通过本文的示例，你可以看到如何用现代 C++ 语法快速实现一个“可排序容器”约束，既可以在编译期检查，又能利用标准库的算法。希望这能激发你在项目中更广泛地使用 TMP 与概念，写出更可靠、更易维护的代码。

C++20 introduced concepts, a language feature that allows programmers to express constraints on template parameters more explicitly and readably. Concepts help you write safer, easier‑to‑understand generic code by filtering template instantiations at compile time. This article delves into the basics of concepts, showcases practical examples, and discusses their impact on template metaprogramming.

---

1. What Are Concepts?

A concept is a compile‑time predicate that can be applied to a type or set of types. It behaves similarly to a type trait but is more expressive and can combine multiple constraints. Concepts are declared with the concept keyword:

template<typename T>
concept Integral = std::is_integral_v <T>;

template<typename T>
concept Incrementable = requires(T a) {
    ++a;          // pre‑increment
    a++;          // post‑increment
};

These declarations tell the compiler that a type T satisfies the Integral concept if `std::is_integral_v

` is true, and that it satisfies `Incrementable` if the required operators are available. — ### 2. Using Concepts in Function Templates Concepts enable *constrained* function templates. Instead of overloading or using SFINAE tricks, you can state the requirement directly: “`cpp template T add(T a, T b) { return a + b; } “` When `add` is instantiated with a non‑integral type, the compiler emits a clear error message indicating that the type does not satisfy `Integral`. “`cpp int main() { std::cout << add(5, 3); // OK // std::cout << add(5.2, 3.1); // Compilation error: double does not satisfy Integral } “` — ### 3. Combining Concepts Concepts can be combined using logical operators. This leads to expressive constraints that mirror mathematical logic: “`cpp template concept SignedIntegral = Integral && std::is_signed_v; template concept FloatingPoint = std::is_floating_point_v ; template requires SignedIntegral || FloatingPoint T absolute(T value) { return value < 0 ? -value : value; } “` The `absolute` function now accepts either signed integral types or any floating‑point type, and the compiler will enforce this rule. — ### 4. Customizing Standard Algorithms Consider the standard library's `std::sort`. We can create a custom overload that only participates for containers whose iterator type satisfies `RandomAccessIterator` and whose value type satisfies a user‑defined `Comparable` concept. “`cpp template concept RandomAccessIterator = std::is_base_of_v<std::random_access_iterator_tag, typename std::iterator_traits::iterator_category>; template concept Comparable = requires(T a, T b) { { a std::convertible_to; }; template void quick_sort(Iter begin, Iter end) { // Implementation omitted for brevity } “` Now, calling `quick_sort` with a list iterator will fail to compile because `std::list` iterators are not random access, providing an immediate and meaningful feedback. — ### 5. Performance and Compile‑Time Guarantees Because concepts perform checks at compile time, they eliminate a large class of runtime errors. For example, a generic matrix library can enforce that the element type supports arithmetic before performing any operations, preventing subtle bugs in user code. Additionally, constraints can sometimes lead to better code generation. The compiler knows exactly which overloads are viable and can optimize away generic dispatch mechanisms, resulting in more efficient machine code. — ### 6. Practical Tips | Tip | Why It Helps | |—–|————–| | **Name concepts clearly** (e.g., `Iterable`, `Sortable`) | Improves readability | | **Use `requires` clauses for non‑template functions** | Keeps signatures clean | | **Prefer concepts over SFINAE where possible** | Safer, clearer errors | | **Document concepts** | Others can reuse your constraints | — ### 7. A Full Example Below is a small but complete program that demonstrates concepts in action: “`cpp #include #include #include #include #include // Concept definitions template concept Integral = std::is_integral_v ; template concept FloatingPoint = std::is_floating_point_v ; template concept Number = Integral || FloatingPoint; // Generic sum template T sum(const std::vector & data) { T total{}; for (const auto& v : data) total += v; return total; } // Generic max template T max(const std::vector & data) { return *std::max_element(data.begin(), data.end()); } int main() { std::vector vi{1, 2, 3, 4}; std::vector vd{1.5, 2.5, 3.5}; std::cout << "Sum of ints: " << sum(vi) << '\n'; std::cout << "Max of ints: " << max(vi) << '\n'; std::cout << "Sum of doubles: " << sum(vd) << '\n'; std::cout << "Max of doubles: " << max(vd) << '\n'; // std::vector vs{“a”, “b”}; // Would fail to compile: std::string not Number } “` Compile with a C++20‑compatible compiler (`-std=c++20` for GCC/Clang). The commented line demonstrates the compile‑time safety: attempting to use `sum` with `std::string` would trigger a constraint violation error. — ### 8. Conclusion C++20 concepts bring a powerful, declarative way to express template requirements. They improve code safety, clarity, and maintainability, and they integrate seamlessly with the rest of the C++ type system. Embracing concepts early in your projects will set a solid foundation for writing robust generic code.