C++ Concepts (C++20) 深度：自定义概念与模板约束的极致表达力

哈喽，各位好！今天咱们要聊点C++20里特别酷的东西：Concepts，也就是C++的概念。这玩意儿就像是给模板参数加上了更严格的“门卫”，让你的代码更安全、更易读，也更易于调试。

第一幕：模板的旧日时光，暗藏的危机

在Concepts出现之前，我们用模板编程，那感觉就像是在黑夜里摸索。模板参数可以是任何东西，编译器只有在实例化的时候才会报错。比如：

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

int main() {
    std::cout << add(5, 3) << std::endl; // OK!
    //std::cout << add("hello", "world") << std::endl; // 编译错误，但错误信息很长很晦涩
    return 0;
}

上面的代码，如果把注释去掉，编译会报错，但是错误信息会很长，而且指向模板内部，而不是 add 函数的调用位置。这意味着你需要花费大量时间来定位问题，这对于大型项目来说简直是噩梦。

第二幕：Concepts登场，拨开迷雾见光明

Concepts就是来解决这个问题的。它允许你给模板参数加上约束，只有满足约束的类型才能被用来实例化模板。

我们先来定义一个简单的concept，比如 Addable，表示类型必须支持加法操作：

template <typename T>
concept Addable = requires(T a, T b) {
    a + b; // 表达式必须有效
};

这个 requires 关键字是Concepts的核心。它指定了一组类型 T 必须满足的条件，也就是一个表达式 a + b 必须是有效的。

现在我们可以用这个 concept 来约束 add 函数：

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

int main() {
    std::cout << add(5, 3) << std::endl; // OK!
    //std::cout << add("hello", "world") << std::endl; // 编译错误，错误信息更清晰！
    return 0;
}

现在，如果你尝试用不支持加法操作的类型（比如字符串）来调用 add 函数，编译器会立即报错，而且错误信息会告诉你："类型 std::string 不满足 concept Addable"。是不是清晰多了？

第三幕：Concept的语法糖，甜蜜的诱惑

C++20提供了一些更简洁的语法来使用Concepts。

• 使用 requires 子句:

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

• 使用 auto 约束参数:

  Addable auto add(Addable auto a, Addable auto b) {
      return a + b;
  }

这些语法糖让代码更简洁易读。但是要注意， auto 约束参数只能用于函数模板，不能用于类模板。

第四幕：自定义Concept，打造专属约束

Concepts的强大之处在于可以自定义。你可以根据自己的需求定义各种各样的concepts。

• Integral Concept:

  判断一个类型是否是整数类型。

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

• FloatingPoint Concept:

  判断一个类型是否是浮点数类型。

  template <typename T>
  concept FloatingPoint = std::is_floating_point_v<T>;

• EqualityComparable Concept:

  判断一个类型是否可以进行相等比较。

  template <typename T>
  concept EqualityComparable = requires(T a, T b) {
      { a == b } -> std::convertible_to<bool>; // 必须可以比较，并且结果可以转换为 bool
      { a != b } -> std::convertible_to<bool>;
  };

• Sortable Concept:

  判断一个类型是否可以进行排序（需要支持小于比较）。

  template <typename T>
  concept Sortable = requires(T a, T b) {
      { a < b } -> std::convertible_to<bool>;
  };

  有了这些自定义的concepts，我们就可以更精确地约束模板参数了。

第五幕：组合Concept，构建复杂的约束

Concepts可以组合使用，构建更复杂的约束。

比如，我们想要定义一个 Number concept，表示类型既可以是整数，也可以是浮点数：

template <typename T>
concept Number = Integral<T> || FloatingPoint<T>;

这里使用了逻辑或运算符 ||，表示类型 T 必须满足 Integral concept 或者 FloatingPoint concept。

我们还可以使用逻辑与运算符 && 来表示类型必须同时满足多个concepts。

template <typename T>
concept SignedIntegral = Integral<T> && std::is_signed_v<T>;

这个 SignedIntegral concept 表示类型必须是整数，并且必须是有符号的。

第六幕：requires子句的进阶用法，更强大的表达力

requires 子句不仅可以用来约束类型，还可以用来约束模板的其他方面，比如成员函数的存在性、静态成员变量的存在性等等。

• 约束成员函数:

  template <typename T>
  concept HasToString = requires(T a) {
      { a.toString() } -> std::convertible_to<std::string>; // 必须有 toString() 方法，并且返回 string
  };

  这个 HasToString concept 表示类型 T 必须有一个 toString() 方法，并且该方法返回一个可以转换为 std::string 的值。

• 约束静态成员变量:

  template <typename T>
  concept HasStaticValue = requires {
      typename T::value_type; // 必须有 value_type 成员类型
      { T::value };           // 必须有 value 静态成员变量
  };

  这个 HasStaticValue concept 表示类型 T 必须有一个名为 value_type 的成员类型，并且必须有一个名为 value 的静态成员变量。

• 约束表达式的值:

  template <typename T>
  concept Positive = requires(T a) {
      a > 0; // a 必须大于 0
  };

  这个 Positive concept 表示类型 T 的值必须大于 0。 注意，这个Concept只能在运行时判断，编译时无法进行检查。

第七幕：应用实例，让Concept落地生根

我们来看几个实际的应用场景，展示Concepts的威力。

• 容器的排序算法:

  假设我们有一个排序算法，需要对容器中的元素进行排序。我们可以使用 Sortable concept 来约束容器中的元素类型：

  template <typename Container>
      requires requires(Container c) {
          typename Container::value_type;  // 容器必须有 value_type
          Sortable<typename Container::value_type>; // 元素类型必须是可排序的
          requires std::ranges::random_access_range<Container>; // 容器必须是随机访问范围
      }
  void sort(Container& container) {
      std::sort(container.begin(), container.end());
  }

  这个 sort 函数只能接受元素类型是可排序的容器。

• 矩阵乘法:

  假设我们有一个矩阵乘法函数，需要对两个矩阵进行乘法运算。我们可以使用 Concepts 来约束矩阵的元素类型：

  template <typename T>
      requires Number<T> // 元素类型必须是数字类型 (整数或浮点数)
  std::vector<std::vector<T>> multiply(const std::vector<std::vector<T>>& a, const std::vector<std::vector<T>>& b) {
      // ... 实现矩阵乘法
  }

  这个 multiply 函数只能接受元素类型是数字类型的矩阵。

第八幕：Concept的局限性，理智看待

Concepts虽然很强大，但也有一些局限性。

• 编译时检查:

  Concepts主要是在编译时进行检查，而不是运行时。这意味着有些错误只能在编译时发现，而不能在运行时发现。例如前面 Positive Concept的例子。

• 复杂的requires子句:

  复杂的 requires 子句可能会使代码难以阅读和理解。需要仔细设计你的Concept，使其简洁明了。

• 编译时间:

  使用Concepts可能会增加编译时间，特别是当你的代码中使用了大量的concepts时。

第九幕：与std::enable_if的比较，新旧交替

在Concepts出现之前，我们通常使用 std::enable_if 来实现类似的功能。 std::enable_if 是一种 SFINAE（Substitution Failure Is Not An Error）技术，它通过在模板参数列表中添加条件来控制模板的可用性。

• std::enable_if 的例子:

  template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
  T add(T a, T b) {
      return a + b;
  }

  这个 add 函数只有在 T 是整数类型时才可用。

• Concepts vs std::enable_if:

  特性	Concepts	std::enable_if
  易读性	更易读，语义更清晰	较难读，语义晦涩
  错误信息	错误信息更清晰，指向错误的位置	错误信息较长，难以定位问题
  编译时检查	编译时检查更严格	编译时检查相对宽松
  表达能力	可以表达更复杂的约束	表达能力相对有限
  标准化	C++20标准的一部分	C++11标准的一部分

  总的来说，Concepts在易读性、错误信息和表达能力方面都优于 std::enable_if。因此，在C++20中，我们应该尽可能使用Concepts来约束模板参数。

第十幕：最佳实践，让Concept发挥最大价值

• 明确你的约束:

  在定义Concept之前，要明确你的模板参数需要满足哪些约束。

• 保持Concept简洁:

  尽量使你的Concept简洁明了，避免过度复杂的 requires 子句。

• 使用标准库提供的Concepts:

  C++标准库提供了一些常用的Concepts，比如 std::integral、std::floating_point 等等。尽量使用这些标准库提供的concepts，避免重复造轮子。

• 测试你的Concepts:

  编写测试用例来验证你的Concepts是否能够正确地约束模板参数。

总结

Concepts是C++20中一个非常强大的特性，它可以帮助我们编写更安全、更易读、更易于调试的模板代码。虽然它有一些局限性，但只要我们合理使用，就能让我们的代码更加健壮和优雅。希望今天的讲解能够帮助你更好地理解和使用Concepts。祝各位编程愉快！