如果 constexpr 而不是标签分派

Question

我想使用 if constexpr 而不是标签调度，但我不确定如何使用它。下面的示例代码。

template<typename T>
struct MyTag
{
   static const int Supported = 0;
};

template<>
struct MyTag<std::uint64_t>
{
  static const int Supported = 1;
};

template<>
struct MyTag<std::uint32_t>
{
  static const int Supported = 1;
};

class MyTest
{
public:
   template<typename T>
   void do_something(T value)
   {
      // instead of doing this
      bool supported = MyTag<T>::Supported;

      // I want to do something like this
      if constexpr (T == std::uint64_t)
          supported = true;
   }
};

Answer 1

一种方法是定义一个 constexpr 谓词来检查其参数的类型，然后 constexpr 切换该谓词的结果。

我认为这种方式很好，因为它将功能逻辑与前提逻辑分开。

#include <iostream>
#include <cstddef>
#include <type_traits>

class MyTest
{
public:
    template<typename T>
    void do_something(T value)
    {
        // define our predicate
        // lambdas are constexpr-if-possible in c++17
        constexpr auto is_supported = [](auto&& x) {
            if constexpr (std::is_same<std::decay_t<decltype(x)>, std::uint64_t>())
                return true;
            else
                return false;
        };

        // use the result of the predicate        
        if constexpr (is_supported(value))
        {
            std::cout << "supported\n";
        }
        else 
        {
            std::cout << "not supported\n";
        }
    }
};

int main()
{
    auto t = MyTest();

    t.do_something(int(0));
    t.do_something(std::uint64_t(0));
    t.do_something(double(0));
    t.do_something(static_cast<unsigned long>(0));  // be careful with std::uint_xx aliases

}

示例结果：

not supported
supported
not supported
supported

另一种表达方式可能是：

class MyTest
{
public:

    template<class T>
    static constexpr bool something_possible(T&&)
    {
        return std::is_same<std::decay_t<T>, std::uint64_t>();
    }

    template<typename T>
    void do_something(T value)
    {
        // switch behaviour on result of constexpr predicate    
        if constexpr (something_possible(value))
        {
            std::cout << "supported\n";
        }
        else 
        {
            std::cout << "not supported\n";
        }
    }
};

Answer 2

通常，类型的运行时询问在使用通用 lambda（也有通用参数）的函数式编程中是有意义的。否则简单的答案可能是：只需声明使用 'required' 类型或使用类型特征等……回到通用 lambda 的主题。

/// <summary>
/// c++ 17 generic lambdas have issues
/// with required types of auto arguments
/// in c++20 this will be fixed with new
/// lambda arguments template declaration syntax
/// until then ...
/// </summary>
namespace required_types
{
    template<typename RQ>
    inline auto  is_required_type = [](const auto & v_ = 0) constexpr -> bool
    {
        using T = std::decay_t< decltype(v_) >;
        return std::is_same<T, RQ>();
    };


    inline auto is_uint64 = [] ( const auto & v_ = 0 ) constexpr -> bool
    {
        return is_required_type<std::uint64_t>(v_);
    };

} // required_types

namespace {

    using namespace required_types;

    inline auto tv = [](const char prompt[] = "", const auto & value) {
        std::cout << prompt << "\ntype:\t" << typeid(decltype(value)).name() << "\nvalue:\t" << value;
    };


    inline auto make_double_value = [](auto value)
    {
        if constexpr (is_uint64(value)) {
            tv("\n\nDoubling required type (std::uint_64):", value);
            return value + value;
        }

        tv("\n\nWill try to double 'illegal' type", value);
        return value + value;
    };

}

一些用法

        // call with 'legal' aka required type
    std::uint64_t u42 = 42u;
    auto double_value_2 = make_double_value(u42);
    tv("\nResult:", double_value_2);

    // call with some 'illegal' types also works
    auto double_value = make_double_value(42u);
    tv("\nResult:", double_value);

    std::string one{"--ONE--"};
    auto double_value_3 = make_double_value(one);
    tv("\nResult:", double_value_3 );

当然，如果有人强烈反对我的介绍，仍然可以使用我的 "required_types":

template<typename T>
void some_proc ( const T && val_ ) {
    using namespace required_types;
      if constexpr ( is_required_type<std::uint64_t>(val_) ) {
            do_something_with_uint64 (val_) ;
      } 
}

我宁愿在 along this answer 的某处使用 std::enable_if 而不是上面的方法。

但是（如前所述）为了解决 C++17 中的一些通用 lambda 问题，我会（大胆地）使用我的命名空间 required_types，并进行一些扩展。

如果 constexpr 而不是标签分派

if constexpr instead of tag dispatch

c++

templates

c++17

if-constexpr