Simplify Code with “if constexpr” in C++17

Introduction

程序设计需要不断地做抉择，抉择便需用到逻辑分派。

Modern C++ 中，有多种方式完成这个任务，例如 Run-time if，Tag dispatching，SFINAE，Partial Specialization 等等。这些方式分为运行期分派和编译期分派，分派的条件称为约束。设计是为了厉行约束，理想上，能在编译期强制表现的约束就应提升到编译期完成。

C++17 又增加了一种编译期方式 Compile-time if；C++20 中，又增加了 Concepts。

本篇就来总结一下各种方式的用法异同（Concepts见下篇）。

Run-time if

运行期 if 就是运行时期才会执行的分支语句，例如：

template <typename T>
void foo(const T& val)
{
    if(std::is_integral<T>::value) {
        std::cout << "integral\n";
    } else {
        std::cout << "non-integral\n";
    }
}

if-else 和 switch 都可以在运行期进行逻辑分派，大部分时候的执行期成本亦微不足道。但是 if-else 要求每一个分支都得编译成功，即使不会执行到的分支，比如返回两个不同类型值的时候，便会出现编译错误。

下面，来看一个贯穿本文的例子。

C++ 有一个 stringstream 字符串流，可以用来读取和写出字符流，我们可以利用它来写一个类型转换工具（C++11 就有一个 std::is_convertible）。

首先，需要判断类型是否可以直接相互转换（包含隐式转换），可以直接转换的则直接转换，不可直接转换的则利用 stringstream 转换。我们使用 convertible 来完成该工作：

template <class T, class U>
class convertible
{
    using small_type = char;
    class big_type { char dummy[2]; };
    static small_type test(T);
    static big_type test(...);
    static U makeU();
public:
    enum { value = sizeof(test(makeU())) == sizeof(small_type) };
};

这里使用了两个稻草人函数 test() 来判断类型是否可以进行转换，两个稻草人函数返回的类型大小不同，如果 U 可隐式转换为 T，则会返回 small_type；若不可转换，则会调用任意参版本，返回 big_type。通过对比两者大小，便能判断两个类型是否能够进行转换。

现在，通过 Run-time if 来完成实际转换：

// Run-time if
template <class T, class U>
void convert(T& to, const U& from)
{
    if(convertible<T, U>::value) {
        to = from;  // error if false!
    } else {
        std::stringstream ss;
        ss << from;
        ss >> to;
    }
}

int main()
{
    int val;
    std::string str{"0706"};
    convert(val, str);

    // output: 
    std::cout << val << std::endl;
}

这里，如果 convertible 的结果为 false，则会编译失败，因为 if-else 的每个分支都要编译通过，即使不会被执行到。

Tag Dispatching

可以使用 tag 来进行编译期流程分派，从而解决 Run-time if 所存在的问题。实现如下：

// Tag dispatching
template <bool v>
struct type_tag { enum { value = v}; };

template <class T, class F>
void convert_impl(T& to, const F& from, type_tag<false>)
{
    std::stringstream ss;
    ss << from;
    ss >> to;
}

template <class T, class F>
void convert_impl(T& to, const F& from, type_tag<true>)
{
    to = from;
}

template <class T, class F>
void convert(T& to, const F& from)
{
    convert_impl(to, from, type_tag<convertible<T, F>::value>());
}

通过 type_tag 将数值转换为型别，由此可以将型别的一个暂时对象传递给重载函数，从而实现编译期分派。测试如下：

int main()
{
    int val;
    std::string str{"0706"};
    double pi = 3.1415;

    convert(val, str);
    std::cout << val << std::endl; // output: 706

    convert(val, pi);
    std::cout << val << std::endl; // output: 3
}

SFINAE

与 Tag-dispatching 密切相关的是 SFINAE，借其实现上述需求，代码如下：

// SFINAE
template <class T, class F,
    typename std::enable_if_t<!convertible<T, F>::value, bool> = true>
void convert(T& to, const F& from)
{
    std::stringstream ss;
    ss << from;
    ss >> to;
}

template <class T, class F,
     typename std::enable_if_t<convertible<T, F>::value, bool> = true>
void convert(T& to, const F& from)
{
    to = from;
}

使用 SFINAE 的效果和 Tag-dispatching 相同，但工作方式不同，Tag-dispatching 使用参数推导来选择合适的 helper 重载，而 SFINAE 直接对主函数操纵重载集。SFINAE 使用起来并不方便，且不易读，有时还需要伴随着一些技巧，不过到了 C++17 以后，我们有更好的武器。

Partial Specialization

另一种方法是直接使用偏特化，通过仿函数来实现逻辑分派。

// Partial specialazation
template <class T, class F, bool> struct convert_functor {};

template <class T, class F>
struct convert_functor<T, F, true>
{
    void operator()(T& to, const F& from) const
    {
        to = from;
    }
};

template <class T, class F>
struct convert_functor<T, F, false>
{
    void operator()(T& to, const F& from) const 
    {
        std::stringstream ss;
        ss << from;
        ss >> to;
    }

    void operator()(std::string& to, const F& from) const
    {
        std::stringstream ss;
        ss << from;
        to = ss.str();
    }
};

template <class T, class F>
void convert(T& to, const F& from)
{
    convert_functor<T, F, convertible<T, F>::value>()(to, from);
}

这种方式最为灵活，但即使只需一个简单二元分派，所需代码相较亦多。

Compile-time if

Compile-Time if 是 C++17 的特性，可以使用它来简单地实现上述需求：

// Compile-time if
template <class T, class F>
void convert(T& to, const F& from)
{
    if constexpr (convertible<T, F>::value) {
        to = from;
    } else {
        std::stringstream ss;
        ss << from;
        ss >> to;
    }
}

与 Run-time if 一样，所有代码都可写于一处，无需像 Tag-dispatching，Partial specialization 那样添加额外的 helper 辅助函数。可以使用 Compile-Time if 的情境下，应该优先考虑使用，以简化代码。但是依旧有一些需要注意的地方。举个例子：

template <typename T>
constexpr auto foo(const T& val)
{
    if constexpr (std::is_integral<T>::value)
    {
        if constexpr (T{} < 10) {
            return val * 2;
        }
    }

    return val;
}

这样使用起来完全没问题：

constexpr auto a = foo(10);   // 20
constexpr auto b = foo("hi"); // hi

而如果合并两个if，结果便不如所愿：

template <typename T>
constexpr auto foo(const T& val)
{
    if constexpr (std::is_integral<T>::value && T{} < 10) 
    {
        return val * 2;
    }

    return val;
}

相同的调用，constexpr auto b = foo("hi"); 会出现编译错误。这是由于 Compile-time if 在条件实例化时需要整个条件都有效，而 T{} < 10 不满足，是以当有多个编译期条件时，应该采用嵌入多个 if 的方式编写代码。

除了 Compile-Time if，C++20 的 Concepts 允许使用简单的语法对模板添加任意 requirements/conditions，下篇来看。