C++ `std::enable_if` 的替代方案：Concepts 与 `if constexpr`

好的，各位观众，各位朋友，欢迎来到今天的“C++奇技淫巧与现代魔法”讲座。今天我们要聊的是一个C++界的老生常谈，却又在现代C++中焕发新生的主题：std::enable_if的替代方案，也就是Concepts和if constexpr。

开场白：enable_if的爱恨情仇

话说当年，C++模板的威力大家都见识过了，那是真香啊！但模板用起来，也常常让人抓狂。你写了一个泛型函数，本意是处理整数和浮点数，结果有人传了个字符串进来，编译器瞬间吐出一屏幕的错误信息，比女朋友生气还可怕。

为了解决这个问题，std::enable_if应运而生。它的作用是，只有当某个条件满足时，才启用（enable）某个函数或类模板。简单来说，就是给模板加了个“准入许可”。

template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
T my_function(T value) {
  // 仅当T是整数类型时，此函数才有效
  return value * 2;
}

这段代码的意思是，my_function函数模板只有在T是整数类型时才会被编译。如果T是其他类型，编译器会直接忽略这个函数。

enable_if确实解决了问题，但它的语法实在过于晦涩。那一长串的模板参数，嵌套的类型traits，还有那让人眼花缭乱的typename = ...，简直就是C++语法复杂性的巅峰之作。

template <typename T,
          typename = std::enable_if_t<
              std::is_integral_v<T> && (sizeof(T) > 1)>> // 丧心病狂的条件
T another_function(T value) {
  return value + 1;
}

这段代码，你第一眼能看出它是干什么的吗？反正我是不能。

所以，程序员们一直在寻找更简单、更优雅的替代方案。而Concepts和if constexpr，就是C++标准委员会给出的答案。

第一部分：Concepts – 让类型约束一目了然

C++20引入了Concepts，它的目标是：让模板的类型约束更加清晰、易懂、易用。Concepts本质上是一组编译时的谓词（predicate），用于检查类型是否满足某些特定的要求。

定义Concept

定义一个Concept非常简单，只需要使用concept关键字，然后指定类型参数和约束条件即可。

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

这个Concept名为Integral，它要求类型T必须是一个整数类型。std::is_integral_v<T>是一个类型trait，用于判断T是否为整数类型。

再来一个稍微复杂点的：

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

这个SignedIntegral Concept，要求类型T既是整数类型，又是带符号的。

使用Concept

有了Concept，我们就可以在模板中使用它来约束类型参数。

template <Integral T> // 使用Concept约束类型T
T my_function(T value) {
  return value * 2;
}

或者，你也可以使用requires子句：

template <typename T>
  requires Integral<T> // 使用requires子句约束类型T
T my_function(T value) {
  return value * 2;
}

这两种写法是等价的。

Concept的组合

Concepts可以像搭积木一样组合起来，形成更复杂的约束条件。

template <typename T>
concept Addable = requires(T a, T b) {
  { a + b } -> std::convertible_to<T>; // 要求a + b的结果可以转换为T类型
};

这个Addable Concept，要求类型T的对象可以进行加法运算，并且结果可以转换为T类型。requires块中的表达式{ a + b } -> std::convertible_to<T>，表示a + b的结果必须能够隐式转换为T类型。

Concept的好处

更清晰的错误信息： 如果你使用了Concept，但传入的类型不满足约束条件，编译器会给出更友好的错误信息，直接告诉你哪个Concept不满足。不再是一堆模板参数的错误，而是明确指出“类型T不满足Integral Concept”。
更易读的代码： 使用Concept可以使模板代码更加简洁易懂，一眼就能看出类型参数的要求。
更好的代码重用： Concepts可以被多个模板重用，避免重复编写类型约束代码。

第二部分：if constexpr – 编译期条件判断的利器

if constexpr是C++17引入的特性，它允许在编译期进行条件判断。只有满足条件的分支才会被编译，不满足条件的分支会被编译器直接忽略。

基本用法

if constexpr的语法和普通的if语句非常相似，只是多了个constexpr关键字。

template <typename T>
auto my_function(T value) {
  if constexpr (std::is_integral_v<T>) {
    // 如果T是整数类型，执行此分支
    return value * 2;
  } else {
    // 否则，执行此分支
    return value;
  }
}

这段代码的意思是，如果T是整数类型，my_function函数返回value * 2；否则，返回value。

if constexpr的优势

编译期优化： if constexpr可以在编译期消除不必要的代码，从而提高程序的运行效率。
更简洁的代码： 相比enable_if，if constexpr的语法更加简洁明了，更容易理解。
更灵活的应用： if constexpr可以用于各种编译期条件判断，例如判断类型是否具有某个成员函数、判断编译器版本等等。

与enable_if的对比

if constexpr和enable_if都可以用于条件编译，但它们的侧重点不同。enable_if主要用于控制函数或类模板是否可用，而if constexpr主要用于在函数或类模板内部进行条件判断。

可以用一个表格来总结一下它们的区别：

特性	`enable_if`	`if constexpr`
作用范围	控制函数/类模板是否可用	在函数/类模板内部进行条件判断
编译时机	模板实例化时	函数/类模板编译时
语法复杂度	较高	较低
错误信息	较差，通常是模板参数错误	较好，能定位到具体分支
适用场景	需要完全排除某个函数/类模板的场景	需要在函数/类模板内部进行条件判断的场景

第三部分：Concepts与if constexpr的结合

Concepts和if constexpr可以结合使用，发挥更大的威力。例如，我们可以使用Concept来约束模板参数，然后使用if constexpr来根据类型参数的不同，执行不同的代码。

template <typename T>
  requires Addable<T>
auto process_value(T value) {
  if constexpr (std::is_integral_v<T>) {
    // 如果T是整数类型，进行整数处理
    return value + 1;
  } else {
    // 否则，进行浮点数处理
    return value + 1.0;
  }
}

这段代码的意思是，process_value函数模板接受一个类型为T的参数，其中T必须满足Addable Concept。如果T是整数类型，函数返回value + 1；否则，函数返回value + 1.0。

第四部分：实战演练：一个简单的类型安全的加法函数

让我们用Concepts和if constexpr来实现一个类型安全的加法函数。这个函数要求两个参数的类型相同，并且支持加法运算。

template <typename T, typename U>
concept SameType = std::is_same_v<T, U>;

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

template <typename T, typename U>
  requires SameType<T, U> && SupportsAddition<T>
T safe_add(T a, U b) {
  return a + b;
}

这个safe_add函数模板接受两个类型为T和U的参数，它要求T和U的类型相同，并且T支持加法运算。如果类型不满足要求，编译器会报错。

我们再加一个if constexpr进去，让它支持不同类型的加法，如果能隐式转换则进行转换。

template <typename T, typename U>
concept ConvertibleTo = std::convertible_to<U, T>;

template <typename T, typename U>
  requires SupportsAddition<T>
auto safe_add(T a, U b) {
  if constexpr(ConvertibleTo<T, U>){
    return a + static_cast<T>(b);
  } else if constexpr(ConvertibleTo<U, T>){
    return static_cast<U>(a) + b;
  } else {
    static_assert(false, "Types are not addable or convertible.");
  }
}

这里我们使用了static_assert，如果类型既不能相加，也不能隐式转换，则会产生编译错误，并且输出自定义的错误信息。

第五部分：总结与展望

Concepts和if constexpr是C++现代化的重要组成部分。它们不仅简化了模板编程的语法，还提高了代码的可读性和可维护性。

Concepts让类型约束更加清晰易懂，可以有效地避免类型错误。
if constexpr可以在编译期进行条件判断，从而提高程序的运行效率。

未来，Concepts和if constexpr将在C++模板编程中发挥越来越重要的作用。它们将帮助我们编写更加安全、高效、易于维护的代码。

最后的彩蛋：std::is_detected – 探测类型是否具有某个特性

在编写泛型代码时，我们经常需要判断类型是否具有某个成员函数或成员变量。std::is_detected是C++20引入的一个类型trait，它可以帮助我们探测类型是否具有某个特性。

template <typename T>
concept HasToString = requires(T a) {
  { a.to_string() } -> std::convertible_to<std::string>;
};

这个HasToString Concept，要求类型T的对象必须具有一个名为to_string的成员函数，该函数返回一个可以转换为std::string类型的值。

结束语

今天的讲座到此结束。希望大家通过今天的学习，能够掌握Concepts和if constexpr的基本用法，并在实际项目中灵活运用它们。记住，编程是一门艺术，需要不断学习、实践、思考，才能成为真正的编程大师。感谢大家的观看！

发表回复 取消回复

发表回复取消回复