template<typename T>

T

T + T

T.size()

T

int

size()

std::vector<int>::size()

operator+

size()

concept

template<typename T>
concept Addable = requires(T a, T b) {
    a + b; // 要求 T 類(lèi)型的對(duì)象可以相加
};

template<Addable T>
T add_values(T a, T b) {
    return a + b;
}

// 現(xiàn)在，如果你嘗試：
// add_values(1, 2); // OK，int 是 Addable 的
// add_values("hello", "world"); // 編譯錯(cuò)誤，std::string 的 operator+ 返回 std::string，但這里我們只檢查了 a+b 是否可調(diào)用
// 更精確的 Addable 應(yīng)該檢查返回類(lèi)型：
template<typename T>
concept BetterAddable = requires(T a, T b) {
    { a + b } -> std::same_as<T>; // 要求 a+b 的結(jié)果類(lèi)型是 T
};
template<BetterAddable T>
T better_add_values(T a, T b) {
    return a + b;
}
// better_add_values("hello", "world"); // 編譯錯(cuò)誤，std::string 的 operator+ 返回 std::string，但我們要求結(jié)果類(lèi)型是 T，這里 T 是 std::string，所以是 OK 的。
// 這里的 BetterAddable 還需要考慮隱式轉(zhuǎn)換或更通用的返回類(lèi)型。
// 實(shí)際上，std::string 的 operator+ 返回 std::string，所以它滿(mǎn)足 BetterAddable。
// 錯(cuò)誤示例：
struct MyStruct {};
// better_add_values(MyStruct{}, MyStruct{}); // 編譯錯(cuò)誤，MyStruct 不支持 operator+

template<Addable T>

T

Addable

X

Addable

sort

template<typename T>

T

operator<

operator<

operator<

T

operator<

Point

operator<

operator<

template<Sortable T>

T

T

print

template<Printable T>
void print(const T& value) { /* ... */ }

template<Container C> // 假設(shè) Container 是一個(gè)概念，表示可迭代的容器
void print(const C& container) { /* ... */ }

Printable

Container

print

所以，從根本上講，Concepts通過(guò)將類(lèi)型約束從隱式的、運(yùn)行時(shí)推導(dǎo)的，轉(zhuǎn)變?yōu)轱@式的、編譯期強(qiáng)制的，極大地提升了泛型代碼的健壯性、可讀性和可維護(hù)性。它讓我們的模板不再是“黑盒”，而是帶有明確說(shuō)明書(shū)的“工具箱”。

C++20 Concepts 的核心語(yǔ)法與常見(jiàn)用法有哪些？

既然知道了Concepts的好處，那我們來(lái)聊聊它的一些核心語(yǔ)法和實(shí)際怎么用。這玩意兒，上手其實(shí)不難，但要用得精妙，還是需要一些實(shí)踐。

最基礎(chǔ)的，就是

concept

requires

1.

concept

登錄后復(fù)制

定義

template<typename T>
concept MyConcept = requires(T var) {
    // 這里的語(yǔ)句是要求 T 必須支持的操作
    // 它不是真的執(zhí)行這些操作，只是檢查它們是否是合法的表達(dá)式
    var.foo(); // 要求 T 必須有成員函數(shù) foo()
    { var + 1 } -> std::same_as<int>; // 要求 var + 1 是一個(gè)合法的表達(dá)式，并且結(jié)果類(lèi)型是 int
    typename T::value_type; // 要求 T 必須有嵌套類(lèi)型 value_type
    requires sizeof(T) > 4; // 嵌套 requires 表達(dá)式，要求 T 的大小大于 4
};

requires

AiPPT模板廣場(chǎng)

AiPPT模板廣場(chǎng)-PPT模板-word文檔模板-excel表格模板

50

查看詳情

• 簡(jiǎn)單要求 (Simple requirements):

  expression;

  登錄后復(fù)制
  檢查表達(dá)式是否合法，不關(guān)心返回值。
• 類(lèi)型要求 (Type requirements):

  typename TypeName;

  登錄后復(fù)制
  檢查是否存在某個(gè)嵌套類(lèi)型。
• 復(fù)合要求 (Compound requirements):

  { expression } -> ReturnType;

  登錄后復(fù)制
  檢查表達(dá)式是否合法，并要求其返回類(lèi)型與

  ReturnType

  登錄后復(fù)制
  兼容（可以隱式轉(zhuǎn)換）。
• noexcept 要求 (Noexcept requirements):

  { expression } noexcept;

  登錄后復(fù)制
  檢查表達(dá)式是否合法，并要求其是

  noexcept

  登錄后復(fù)制
  的。
• 嵌套要求 (Nested requirements):

  requires nested_concept<T>;

  登錄后復(fù)制
  或者

  requires another_expression;

  登錄后復(fù)制
  允許在

  requires

  登錄后復(fù)制
  表達(dá)式內(nèi)部再使用

  requires

  登錄后復(fù)制
  表達(dá)式，或者引用其他概念。

2. Concepts 的使用方式

定義好

concept

• 直接作為類(lèi)型約束：

  template<Printable T> // 要求 T 滿(mǎn)足 Printable 概念
  void print_value(const T& val) {
      // ...
  }

  登錄后復(fù)制

• requires

  登錄后復(fù)制
  子句： 當(dāng)概念比較復(fù)雜，或者你想給一個(gè)函數(shù)模板添加約束，但又不想專(zhuān)門(mén)定義一個(gè)

  concept

  登錄后復(fù)制
  時(shí)：

  template<typename T>
  void process(T val) requires (std::is_integral_v<T> && sizeof(T) > 4) {
      // 只有 T 是整型且大小大于4字節(jié)時(shí)才能調(diào)用
  }

  登錄后復(fù)制

  或者結(jié)合

  requires

  登錄后復(fù)制
  表達(dá)式：

  template<typename T>
  void process_complex(T val) requires requires(T x) { x.method(); { x + 1 } -> std::same_as<int>; } {
      // 這種方式直接在 requires 子句里寫(xiě)了表達(dá)式
  }

  登錄后復(fù)制
• 簡(jiǎn)寫(xiě)模板語(yǔ)法 (Abbreviated Function Templates)： 這是C++20的一個(gè)甜點(diǎn)，當(dāng)你只用一個(gè)概念約束一個(gè)類(lèi)型時(shí)，可以省略

  template<typename T>

  登錄后復(fù)制
  ：

  // 替代 template<Printable T> void print_value(const T& val)
  void print_value(Printable auto& val) {
      // ...
  }

  登錄后復(fù)制

  這里的

  Printable auto

  登錄后復(fù)制
  就表示

  auto

  登錄后復(fù)制
  推導(dǎo)出的類(lèi)型必須滿(mǎn)足

  Printable

  登錄后復(fù)制
  概念。

3. 常見(jiàn)用法示例

• 可比較類(lèi)型：

  template<typename T>
  concept EqualityComparable = requires(T a, T b) {
      { a == b } -> std::convertible_to<bool>;
      { a != b } -> std::convertible_to<bool>;
  };
  
  template<EqualityComparable T>
  bool are_equal(const T& a, const T& b) {
      return a == b;
  }

  登錄后復(fù)制

• 可調(diào)用對(duì)象：

  template<typename F, typename... Args>
  concept Invocable = requires(F f, Args... args) {
      std::invoke(f, args...); // 要求 F 可以被 Args 調(diào)用
  };
  
  template<Invocable<int, int> Func> // 要求 Func 可以被兩個(gè) int 調(diào)用
  int apply_func(Func f, int a, int b) {
      return f(a, b);
  }

  登錄后復(fù)制

• 容器概念 (Ranges 庫(kù)中的 Concepts)： C++20的Ranges庫(kù)大量使用了Concepts，比如

  std::ranges::range

  登錄后復(fù)制
  ，

  std::ranges::input_range

  登錄后復(fù)制
  等。

  #include <ranges>
  #include <vector>
  #include <iostream>
  
  template<std::ranges::input_range R> // 要求 R 是一個(gè)輸入范圍
  void print_elements(const R& r) {
      for (const auto& elem : r) {
          std::cout << elem << " ";
      }
      std::cout << std::endl;
  }
  
  // print_elements(std::vector<int>{1, 2, 3}); // OK
  // print_elements(5); // 編譯錯(cuò)誤，int 不是一個(gè) range

  登錄后復(fù)制

這些例子展示了Concepts如何讓我們的泛型代碼變得更具表達(dá)力、更安全。它不只是一個(gè)語(yǔ)法糖，更是一種思維模式的轉(zhuǎn)變，讓我們?cè)谠O(shè)計(jì)模板時(shí)就能考慮到類(lèi)型可能遇到的所有“邊界條件”。

如何利用 C++20 Concepts 編寫(xiě)更易于維護(hù)和擴(kuò)展的泛型代碼？

這其實(shí)是Concepts最深層次的價(jià)值體現(xiàn)。它不僅僅是讓錯(cuò)誤信息好看，更是對(duì)泛型編程范式的一次重塑，讓代碼庫(kù)能更好地“呼吸”和“成長(zhǎng)”。

1. 明確的接口，降低維護(hù)成本

我們都知道，好的接口設(shè)計(jì)是降低維護(hù)成本的關(guān)鍵。在Concepts出現(xiàn)之前，模板的接口是隱式的，你得通過(guò)閱讀模板的實(shí)現(xiàn)代碼，甚至通過(guò)看它引發(fā)的編譯錯(cuò)誤，才能反推出它對(duì)類(lèi)型有什么要求。這簡(jiǎn)直是維護(hù)人員的噩夢(mèng)。

有了Concepts，模板的“契約”變得顯式化。當(dāng)你看到一個(gè)

template<Sortable T>

T

例如，如果你要擴(kuò)展一個(gè)舊的排序算法，使其支持新的數(shù)據(jù)結(jié)構(gòu)。在沒(méi)有Concepts時(shí)，你可能需要嘗試編譯，然后根據(jù)冗長(zhǎng)的錯(cuò)誤信息去猜測(cè)新數(shù)據(jù)結(jié)構(gòu)缺少了什么。有了Concepts，你只需要查看排序算法所依賴(lài)的Concepts定義，就能清晰地知道新數(shù)據(jù)結(jié)構(gòu)需要實(shí)現(xiàn)哪些操作才能滿(mǎn)足要求。

2. 更好的模塊化和組合性

Concepts本身就是模塊化的。你可以定義一些基礎(chǔ)的Concepts，比如

EqualityComparable

Addable

Callable

template<typename T>
concept Numeric = std::is_arithmetic_v<T>; // 基礎(chǔ)概念：是算術(shù)類(lèi)型

template<typename T>
concept Ordered = requires(T a, T b) {
    { a < b } -> std::convertible_to<bool>;
    { a > b } -> std::convertible_to<bool>;
}; // 基礎(chǔ)概念：可排序

template<typename T>
concept SortableNumeric = Numeric<T> && Ordered<T>; // 組合概念：既是數(shù)字又可排序

template<SortableNumeric T>
void sort_data(std::vector<T>& data) {
    std::sort(data.begin(), data.end());
}

這種組合性讓Concepts的定義變得非常靈活和可復(fù)用。當(dāng)你需要一個(gè)新的復(fù)雜概念時(shí)，你不需要從頭開(kāi)始寫(xiě)一大堆

requires

3. 精確的約束重載，提升代碼適應(yīng)性

在泛型編程中，我們經(jīng)常會(huì)遇到這樣的場(chǎng)景：對(duì)于某些特定類(lèi)型的參數(shù)，我們希望提供一個(gè)優(yōu)化過(guò)的、或者行為略有不同的實(shí)現(xiàn)。以前，這通常通過(guò)模板特化或者SFINAE（Substitution Failure Is Not An Error）來(lái)實(shí)現(xiàn)。SFINAE雖然強(qiáng)大，但語(yǔ)法復(fù)雜且難以閱讀，容易出錯(cuò)。

Concepts提供了更優(yōu)雅的解決方案——約束重載。你可以定義多個(gè)函數(shù)模板，它們的名字相同，但它們的Concepts約束不同。編譯器會(huì)根據(jù)傳入的類(lèi)型，選擇最符合約束的那個(gè)版本。

// 通用打印函數(shù)
template<typename T>
concept Printable = requires(std::ostream& os, const T& val) {
    os << val;
};

template<Printable T>
void print_item(const T& item) {
    std::cout << "Generic print: " << item << std::endl;
}

// 針對(duì)容器的特殊打印函數(shù)
template<typename T>
concept Container = requires(T c) {
    c.begin();
    c.end();
    c.empty();
    // 還可以加上更多要求，比如 value_type
};

template<Container C>
void print_item(const C& container) {
    std::cout << "Container print: [";
    bool first = true;
    for (const auto& item : container) {
        if (!first) std::cout << ", ";
        std::cout << item; // 這里假設(shè)容器的元素也是 Printable 的
        first = false;
    }
    std::cout << "]" << std::endl;
}

// print_item(123); // 調(diào)用 Generic print
// print_item(std::vector<int>{1, 2, 3}); // 調(diào)用 Container print

在這個(gè)例子中，

print_item

std::vector<int>

Printable

vector