C++20核心特性解析：概念、范围与协程

C++20：现代C++的重大飞跃

欢迎来到C++20的世界，这是继C++11之后最重要的语言标准更新！C++20引入了一系列革命性特性，从根本上改变了我们编写C++代码的方式。想象你手中有一部功能手机升级到了智能手机——C++20带来的变化同样深刻。三大核心特性——概念(Concepts)、范围(Ranges)和协程(Coroutines)，分别改进了泛型编程、数据处理和异步编程的方式。

这些新特性不仅让代码更简洁、更安全，还显著提高了开发效率和运行时性能。无论你是开发高性能计算应用、游戏引擎还是企业级软件，掌握C++20都将使你如虎添翼。让我们深入探索这些特性，了解它们如何解决长期存在的编程难题。

概念(Concepts)：泛型编程的新范式

概念基础：约束模板参数

概念(Concepts)是C++20最受期待的特性之一，它解决了模板编程中长期存在的两个问题：晦涩的错误信息和缺乏明确的接口约束。

#include <iostream>
#include <concepts>// 定义一个概念：可加类型
template <typename T>
concept Addable = requires(T a, T b) {{ a + b } -> std::convertible_to<T>;
};// 使用概念约束函数模板
template <Addable T>
T add(T a, T b) {return a + b;
}// 传统模板与概念化模板对比
template <typename T> // 传统方式
auto oldAdd(T a, T b) -> decltype(a + b) {return a + b;
}// 更复杂的概念
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;template <Numeric T>
T square(T x) {return x * x;
}int main() {std::cout << add(3, 4) << "\n";      // 正确：int满足Addablestd::cout << add(2.5, 3.7) << "\n";  // 正确：double满足Addable// std::cout << add("Hello", "World"); // 错误：const char*不满足Addablestd::cout << oldAdd(5, 6) << "\n";   // 传统模板仍可用std::cout << square(4) << "\n";       // 11std::cout << square(3.14) << "\n";    // 9.8596return 0;
}

概念组合与约束表达式

概念可以组合使用，创建更复杂的约束：

#include <iostream>
#include <concepts>
#include <vector>
#include <type_traits>// 组合概念
template <typename T>
concept PrintableAndSwappable = requires(T a, T b) {{ std::cout << a } -> std::same_as<std::ostream&>;{ std::swap(a, b) };
};// 约束表达式
template <typename Container>
concept ContainerWithIntIndex = requires(Container c, int i) {{ c[i] } -> std::convertible_to<typename Container::value_type>;{ c.size() } -> std::same_as<typename Container::size_type>;
};// 使用概念约束类模板
template <PrintableAndSwappable T>
class Wrapper {
public:Wrapper(T val) : value(val) {}void print() const {std::cout << "Wrapper: " << value << "\n";}void swapWith(Wrapper& other) {std::swap(value, other.value);}private:T value;
};// 概念约束的auto参数
void printContainer(const ContainerWithIntIndex auto& container) {for (size_t i = 0; i < container.size(); ++i) {std::cout << container[i] << " ";}std::cout << "\n";
}int main() {Wrapper<int> w1(42), w2(100);w1.print();w2.print();w1.swapWith(w2);w1.print();w2.print();std::vector<int> vec = {1, 2, 3, 4, 5};printContainer(vec);// Wrapper<std::vector<int>> wv(vec); // 错误：vector不满足PrintableAndSwappablereturn 0;
}

标准概念库

C++20在<concepts>头文件中提供了许多预定义概念：

#include <iostream>
#include <concepts>
#include <iterator>
#include <vector>// 使用标准概念
template <std::input_iterator Iter>
void printRange(Iter begin, Iter end) {for (; begin != end; ++begin) {std::cout << *begin << " ";}std::cout << "\n";
}template <std::integral T>
T factorial(T n) {if (n <= 1) return 1;return n * factorial(n - 1);
}template <std::semiregular T>
class DefaultConstructibleWrapper {T value;
public:DefaultConstructibleWrapper() = default;explicit DefaultConstructibleWrapper(T v) : value(v) {}
};int main() {std::vector<int> vec = {5, 3, 1, 4, 2};printRange(vec.begin(), vec.end());std::cout << "5! = " << factorial(5) << "\n";// std::cout << factorial(5.5) << "\n"; // 错误：不满足std::integralDefaultConstructibleWrapper<int> wrapper1;DefaultConstructibleWrapper<int> wrapper2(42);return 0;
}

范围(Ranges)：数据处理的新方式

范围视图与管道操作符

范围库简化了数据处理代码，提供了声明式的编程风格：

#include <iostream>
#include <vector>
#include <ranges> // C++20范围库int main() {namespace views = std::views;std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 过滤偶数并平方auto result = numbers | views::filter([](int n) { return n % 2 == 0; })| views::transform([](int n) { return n * n; });std::cout << "过滤并转换后的结果: ";for (int n : result) {std::cout << n << " ";}std::cout << "\n";// 生成无限序列并取前10个auto infinite = views::iota(1)      // 无限序列1, 2, 3, ...| views::take(10);    // 取前10个std::cout << "iota视图前10个元素: ";for (int n : infinite) {std::cout << n << " ";}std::cout << "\n";// 反转范围auto reversed = numbers | views::reverse;std::cout << "反转后的向量: ";for (int n : reversed) {std::cout << n << " ";}std::cout << "\n";// 范围适配器组合auto complex = numbers | views::drop(3)               // 跳过前3个| views::take(5)                // 取接下来5个| views::transform([](int n) {  // 每个元素加10return n + 10; });std::cout << "复杂转换结果: ";for (int n : complex) {std::cout << n << " ";}std::cout << "\n";return 0;
}

范围算法

范围库提供了传统STL算法的范围版本：

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>int main() {namespace ranges = std::ranges;std::vector<int> numbers = {5, 3, 1, 4, 2, 6, 8, 7, 9, 10};// 范围排序ranges::sort(numbers);std::cout << "排序后的范围: ";for (int n : numbers) {std::cout << n << " ";}std::cout << "\n";// 范围查找auto it = ranges::find(numbers, 7);if (it != numbers.end()) {std::cout << "找到7在位置: " << ranges::distance(numbers.begin(), it) << "\n";}// 范围计数int count = ranges::count_if(numbers, [](int n) { return n % 2 == 0; });std::cout << "偶数个数: " << count << "\n";// 范围转换std::vector<int> squares;ranges::transform(numbers, std::back_inserter(squares),[](int n) { return n * n; });std::cout << "平方数: ";for (int n : squares) {std::cout << n << " ";}std::cout << "\n";return 0;
}

自定义范围视图

#include <iostream>
#include <ranges>
#include <vector>// 自定义范围视图：斐波那契数列
class FibonacciView : public std::ranges::view_interface<FibonacciView> {
public:struct iterator {using value_type = unsigned long long;using difference_type = std::ptrdiff_t;unsigned long long a = 0, b = 1;value_type operator*() const { return a; }iterator& operator++() {auto next = a + b;a = b;b = next;return *this;}iterator operator++(int) {auto temp = *this;++*this;return temp;}bool operator==(const iterator&) const { return false; }};iterator begin() const { return {}; }std::unreachable_sentinel_t end() const { return {}; }
};// 自定义范围适配器：相邻差分
template <std::ranges::input_range R>
class AdjacentDifferenceView : public std::ranges::view_interface<AdjacentDifferenceView<R>> {
private:R range;public:explicit AdjacentDifferenceView(R r) : range(std::move(r)) {}struct iterator {using value_type = std::ranges::range_value_t<R>;using difference_type = std::ranges::range_difference_t<R>;std::ranges::iterator_t<R> current;std::ranges::iterator_t<R> end;value_type prev;bool is_first = true;value_type operator*() const {return is_first ? *current : (*current - prev);}iterator& operator++() {if (!is_first) prev = *current;++current;is_first = false;return *this;}iterator operator++(int) {auto temp = *this;++*this;return temp;}bool operator==(const iterator& other) const {return current == other.current;}};iterator begin() {auto it = std::ranges::begin(range);return {it, std::ranges::end(range), *it, true};}iterator end() {return {std::ranges::end(range), std::ranges::end(range), {}, false};}
};// 自定义范围适配器闭包对象
inline constexpr auto adjacent_difference = []<std::ranges::input_range R>(R&& r) {return AdjacentDifferenceView<std::ranges::views::all_t<R>>(std::forward<R>(r));
};int main() {// 使用自定义斐波那契视图std::cout << "斐波那契数列前10项: ";for (auto n : FibonacciView() | std::views::take(10)) {std::cout << n << " ";}std::cout << "\n";// 使用自定义相邻差分适配器std::vector<int> data = {2, 4, 7, 11, 16, 22};std::cout << "原始数据: ";for (int n : data) std::cout << n << " ";std::cout << "\n相邻差分: ";for (int n : adjacent_difference(data)) {std::cout << n << " ";}std::cout << "\n";return 0;
}

协程(Coroutines)：异步编程的新范式

协程基础

协程是可挂起和恢复的函数，极大简化了异步编程：

#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>// 简单的协程返回类型
struct Generator {struct promise_type {int current_value;Generator get_return_object() {return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};}std::suspend_always initial_suspend() { return {}; }std::suspend_always final_suspend() noexcept { return {}; }void unhandled_exception() { std::terminate(); }std::suspend_always yield_value(int value) {current_value = value;return {};}void return_void() {}};std::coroutine_handle<promise_type> coro;explicit Generator(std::coroutine_handle<promise_type> h) : coro(h) {}~Generator() { if (coro) coro.destroy(); }int current() { return coro.promise().current_value; }bool next() {if (!coro.done()) {coro.resume();return !coro.done();}return false;}
};// 生成器协程
Generator range(int start, int end, int step = 1) {for (int i = start; i < end; i += step) {co_yield i; // 挂起并返回值}co_return; // 协程结束
}int main() {std::cout << "简单协程示例:\n";Generator gen = range(1, 10, 2);while (gen.next()) {std::cout << gen.current() << " ";}std::cout << "\n";return 0;
}

异步任务协程

#include <iostream>
#include <coroutine>
#include <thread>
#include <future>
#include <chrono>// 异步任务协程框架
struct AsyncTask {struct promise_type {std::promise<int> promise;AsyncTask get_return_object() {return AsyncTask{promise.get_future()};}std::suspend_never initial_suspend() { return {}; }std::suspend_never final_suspend() noexcept { return {}; }void unhandled_exception() {promise.set_exception(std::current_exception());}void return_value(int value) {promise.set_value(value);}};std::future<int> result;explicit AsyncTask(std::future<int> f) : result(std::move(f)) {}int get() { return result.get(); }
};// 模拟异步IO操作
int asyncIOOperation(int input) {std::this_thread::sleep_for(std::chrono::seconds(1));return input * 2;
}// 协程异步任务
AsyncTask coroutineAsyncTask(int input) {std::cout << "协程开始执行\n";// 模拟异步操作auto result1 = co_await std::async([input] { return asyncIOOperation(input); });std::cout << "第一阶段完成: " << result1 << "\n";auto result2 = co_await std::async([result1] { return asyncIOOperation(result1); });std::cout << "第二阶段完成: " << result2 << "\n";co_return result2;
}int main() {std::cout << "启动异步协程任务\n";auto task = coroutineAsyncTask(5);std::cout << "主线程继续执行其他工作...\n";std::this_thread::sleep_for(std::chrono::milliseconds(500));std::cout << "主线程其他工作完成\n";auto result = task.get();std::cout << "最终结果: " << result << "\n";return 0;
}

协程与生成器模式

#include <iostream>
#include <coroutine>
#include <vector>// 生成器协程
template <typename T>
struct Generator {struct promise_type;using handle_type = std::coroutine_handle<promise_type>;struct promise_type {T current_value;Generator get_return_object() {return Generator{handle_type::from_promise(*this)};}std::suspend_always initial_suspend() { return {}; }std::suspend_always final_suspend() noexcept { return {}; }void unhandled_exception() { std::terminate(); }std::suspend_always yield_value(T value) {current_value = value;return {};}void return_void() {}};handle_type coro;explicit Generator(handle_type h) : coro(h) {}~Generator() { if (coro) coro.destroy(); }Generator(const Generator&) = delete;Generator& operator=(const Generator&) = delete;Generator(Generator&& other) noexcept : coro(other.coro) {other.coro = nullptr;}Generator& operator=(Generator&& other) noexcept {if (this != &other) {if (coro) coro.destroy();coro = other.coro;other.coro = nullptr;}return *this;}T current() { return coro.promise().current_value; }bool next() {if (!coro.done()) {coro.resume();return !coro.done();}return false;}
};// 生成斐波那契数列的协程
Generator<int> fibonacci(int limit) {int a = 0, b = 1;while (a <= limit) {co_yield a;auto next = a + b;a = b;b = next;}
}// 生成过滤后序列的协程
template <std::predicate<int> Pred>
Generator<int> filter(Generator<int> source, Pred predicate) {while (source.next()) {if (predicate(source.current())) {co_yield source.current();}}
}int main() {std::cout << "斐波那契数列(<=1000): ";auto fib = fibonacci(1000);while (fib.next()) {std::cout << fib.current() << " ";}std::cout << "\n";std::cout << "斐波那契偶数(<=1000): ";auto evenFib = filter(fibonacci(1000), [](int n) { return n % 2 == 0; });while (evenFib.next()) {std::cout << evenFib.current() << " ";}std::cout << "\n";return 0;
}

其他重要C++20特性

三向比较运算符(<=>)

#include <iostream>
#include <compare>
#include <vector>
#include <algorithm>class Point {
public:int x, y;Point(int x, int y) : x(x), y(y) {}// 默认三向比较auto operator<=>(const Point&) const = default;// 传统比较运算符自动生成bool operator==(const Point&) const = default;
};int main() {Point p1(1, 2), p2(1, 3), p3(2, 1);std::cout << std::boolalpha;std::cout << "p1 < p2: " << (p1 < p2) << "\n";   // truestd::cout << "p1 == p2: " << (p1 == p2) << "\n"; // falsestd::cout << "p1 <=> p3: " << (p1 <=> p3)._Value << "\n"; // -1 (less)std::vector<Point> points = {p3, p1, p2};std::sort(points.begin(), points.end());std::cout << "排序后的点:\n";for (const auto& p : points) {std::cout << "(" << p.x << ", " << p.y << ") ";}std::cout << "\n";return 0;
}

格式化库(std::format)

#include <iostream>
#include <format>
#include <string>
#include <numbers>int main() {std::string name = "Alice";int age = 30;double salary = 65000.50;// 基本格式化std::string message = std::format("姓名: {}, 年龄: {}, 工资: {:.2f}", name, age, salary);std::cout << message << "\n";// 位置参数std::cout << std::format("{1}今年{0}岁\n", age, name);// 填充和对齐std::cout << std::format("{:*^20}\n", "居中"); // ********居中********std::cout << std::format("{:>10}\n", "右对齐"); // '     右对齐'std::cout << std::format("{:<10}\n", "左对齐"); // '左对齐     '// 数字格式化std::cout << std::format("十六进制: {:x}\n", 255); // ffstd::cout << std::format("科学计数: {:.2e}\n", 123456.789); // 1.23e+05// 标准数学常量std::cout << std::format("π ≈ {:.5f}\n", std::numbers::pi);std::cout << std::format("e ≈ {:.5f}\n", std::numbers::e);return 0;
}

constexpr增强

#include <iostream>
#include <array>
#include <bit> // C++20位操作
#include <memory>// C++20允许constexpr动态内存分配
constexpr auto createArray(int size) {std::unique_ptr<int[]> arr(new int[size]);for (int i = 0; i < size; ++i) {arr[i] = i * i;}return arr;
}// constexpr向量(简化版)
template <typename T, size_t N>
class ConstexprVector {
public:constexpr ConstexprVector() = default;constexpr void push_back(T value) {if (size_ >= N) throw "超出容量";data_[size_++] = value;}constexpr T operator[](size_t index) const {return data_[index];}constexpr size_t size() const { return size_; }private:std::array<T, N> data_{};size_t size_ = 0;
};int main() {// 编译时动态分配constexpr auto squares = createArray(5);static_assert(squares[3] == 9, "3的平方应为9");// 编译时向量操作constexpr ConstexprVector<int, 10> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);static_assert(vec.size() == 3, "向量大小应为3");// 编译时位操作constexpr uint8_t bits = 0b10101010;static_assert(std::popcount(bits) == 4, "应有4个设置位");static_assert(std::rotl(bits, 1) == 0b01010101, "旋转左移1位");std::cout << "编译时计算验证通过\n";return 0;
}

综合案例：现代C++20应用

#include <iostream>
#include <ranges>
#include <coroutine>
#include <format>
#include <vector>
#include <concepts>
#include <algorithm>
#include <numeric>// 概念约束：数值类型
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;// 协程生成器：数值范围
template <Numeric T>
class RangeGenerator {
public:struct promise_type;using handle_type = std::coroutine_handle<promise_type>;struct promise_type {T current;T step;T stop;RangeGenerator get_return_object() {return RangeGenerator{handle_type::from_promise(*this)};}std::suspend_always initial_suspend() { return {}; }std::suspend_always final_suspend() noexcept { return {}; }void unhandled_exception() { std::terminate(); }std::suspend_always yield_value(T value) {current = value;return {};}void return_void() {}};handle_type coro;explicit RangeGenerator(handle_type h) : coro(h) {}~RangeGenerator() { if (coro) coro.destroy(); }RangeGenerator(const RangeGenerator&) = delete;RangeGenerator& operator=(const RangeGenerator&) = delete;RangeGenerator(RangeGenerator&& other) noexcept : coro(other.coro) {other.coro = nullptr;}class iterator {public:using iterator_category = std::input_iterator_tag;using value_type = T;using difference_type = std::ptrdiff_t;using pointer = T*;using reference = T&;explicit iterator(handle_type coro = nullptr) : coro(coro) {}iterator& operator++() {coro.resume();if (coro.done()) coro = nullptr;return *this;}iterator operator++(int) {iterator temp = *this;++*this;return temp;}T operator*() const { return coro.promise().current; }bool operator==(const iterator& other) const {return coro == other.coro;}private:handle_type coro;};iterator begin() {if (!coro.done()) coro.resume();return iterator{coro};}iterator end() { return iterator{}; }
};// 数值范围协程
template <Numeric T>
RangeGenerator<T> range(T start, T stop, T step = 1) {for (T i = start; i < stop; i += step) {co_yield i;}
}// 使用概念和范围的统计函数
template <Numeric T>
auto analyzeData(const std::ranges::range auto& data) {auto [min, max] = std::ranges::minmax(data);auto sum = std::accumulate(data.begin(), data.end(), T{0});auto count = std::ranges::distance(data);double average = static_cast<double>(sum) / count;return std::make_tuple(min, max, sum, average);
}int main() {// 生成数值范围auto numbers = range(1.0, 10.0, 0.5);// 过滤和转换auto processed = numbers | std::views::filter([](double x) { return x > 3.0; })| std::views::transform([](double x) { return x * x; });// 转换为向量std::vector<double> results(processed.begin(), processed.end());// 分析数据auto [min, max, sum, avg] = analyzeData<double>(results);// 格式化输出std::cout << std::format("统计结果:\n""最小值: {:.2f}\n""最大值: {:.2f}\n""总和: {:.2f}\n""平均值: {:.2f}\n",min, max, sum, avg);// 三向比较auto cmp = 3.5 <=> 4.2;std::cout << "3.5 <=> 4.2: " << static_cast<int>(cmp._Value) << "\n";return 0;
}