在两个不同的命名函数之间进行选择的特征的替代方法是什么？

Question

还有......我不想使用函数指针，我真的想直接使用函数本身（因此可以内联或应用其他优化）。

假设：我有一个模板函数/类，它将计算一些数学内容，模板参数是整数类型，可能是 unsigned int32_t 或 unsigned int64_t。

在某些时候我需要随机数，所以我需要一个生成器，在一种情况下我将使用mt19937，在另一种情况下使用mt19937_64。所以实际的类型名称是不同的，但我必须选择一个并实际写在源代码中。

显然，整数类型的特征类可以正常工作（这就是我现在正在做的事情）。但在我看来，这种一次性使用在语法方面相当重量级，而且有点非本地（如果你明白我的意思，请阅读源代码）。

另一种方法是将生成器的使用封装在一些（通用）函数中，并为我的两个整数类型提供它的完全专业化。这其实没问题。

但是：还有其他选择吗？我可以在这里使用某种编译时“if”或“switch”（不完全是enable-if，它启用/禁用模板实例化）吗？或者别的什么（也许比我没看到的模板元编程更简单）？

(P.S. 请不要挂断mt19937 和mt19937_64 - 我知道它们都是我可以用我的整数类型实例化自己的类型的别名 - 但我更愿意使用标准定义他们的大量相当神奇的数字。另外，我不仅对mt19937/mt19937_64 感兴趣，还对其他类似案例感兴趣。）

这是我的特征类的代码目前的样子：

template <class Base>
struct traits { };

template <>
struct traits<unsigned __int32>
{
    using base_t = unsigned __int32;
    static const int nbits = std::numeric_limits<base_t>::digits;
    using random_engine_t = std::mt19937;
    ...
};

template <>
struct traits<unsigned __int64>
{
    using base_t = unsigned __int64;
    static const int nbits = std::numeric_limits<base_t>::digits;
    using random_engine_t = std::mt19937_64;
    ...
};

Answer 1

方法 #1：生成干净的分布式特征类型。

一些实用程序：

template<class T>struct tag_t{using type=T;};
template<class T>constexpr tag_t<T> tag = {};
template<class Tag>using type=typename Tag::type;

现在，我们创建标记重载而不是特征类：

tag<std::mt1337> which_random_engine( tag_t<int> );
tag<std::mt1337_64> which_random_engine( tag_t<std::int64_t> );

它可以让你在任何地方进行这样的重载。

我们可以用它来定义一个traits类：

template<class T>
using random_engine_for = type<decltype(which_random_engine(tag<T>))>;

用途：

random_engine_for<T> engine;

---

方法 #2：

template<class A, class B> struct zpair_t {};
template<class T, class...> struct lookup_t {};
template<class T, class A, class B, class...Ts>
struct lookup_t<T, zpair_t<A, B>, Ts...>:lookup_t<T, Ts...>{};
template<class T, class B, class...Ts>
struct lookup_t<T, zpair_t<T, B>, Ts...>:tag_t<B>{};
template<class T, class Default, class...Ts>
struct lookup_t<T, tag_t<Default>, Ts...>:tag_t<Default>{
  static_assert(sizeof(Ts...)==0, "Default must be last");
};

template<class A, class B> using kv=zpair_t<A,B>;
template<class Default> using otherwise=tag_t<Default>;
template<class T, class...KVs>
using lookup = type<lookup_t<T, KVs...>>;

using random_engine_t = 
  lookup< T,
    kv< int, std::mt19937 >,
    kv< std::int64_t, std::mt19937_64 >,
    otherwise<void> // optional
  >;

它使用一些相同的实用程序，并执行编译时类型映射。

我确信boost 在语法上有更好的变化。

Answer 2

你可以使用std::conditional:

template <class Int>
using engine_t = std::conditional_t<
    std::is_same<Int, uint32_t>{},
    std::mt19937,
    std::mt19937_64
>;

假设Int 只能是uint32_t 或uint64_t。随着您最终使用的类型越多，这会变得越来越复杂。它也有安全问题 - 如果现在支持uint16_t 怎么办？您最终会默默地使用mt19937_64，这可能不是正确的决定。

---

您也可以使用mpl::map 方法：

using engine_map = mpl::map<
    mpl::pair<uint32_t, std::mt19937>,
    mpl::pair<uint64_t, std::mt19937_64>
>;

template <class Int>
using engine_t = typename mpl::at<engine_map, Int>::type;

这可以更好地扩展到更多类型。如果您引入一种新类型，这也将是一个硬编译错误，这可能是一种更好的方法。

---

我认为这是否比特征类更好或更差是一个偏好问题，并且取决于您项目的其余部分。