c++ - 对于类型修改特征，我应该为 typename::transform<...>::type 提供一个 template-typedef(又名 using)便利包装器吗？

Question

我想知道随着模板类型定义的可用性，我应该为转换类型的类提供方便的包装器。考虑这个(无用的)例子:

template< T >
struct whatever
{
   typedef typename std::conditional< sizeof(T) <= sizeof(void*),
                                      int, long >::type type;
};

这里，std::conditional 是标题中的 transform，与 typename transform<...>::type 一起使用。此外，whatever 本身也是一个 transform，使用方式相同。

有了模板类型定义(又名 using )，我可以将界面更改为:

template< T >
using whatever = typename std::conditional< sizeof(T) <= sizeof(void*),
                                            int, long >::type;

这简化了使用。对于所有这些情况都可以这样做，但是由于所需的(部分)特化，有时您最终会得到一个实现类和一个包装器。在 std::conditional 的情况下，您可能最终将其移动到 std::impl::conditional<...> 并提供另一个包装器作为

namespace std
{
  namespace impl
  {
    // "classic" implementation of std::conditional
  }

  template< bool B, typename T, typename F >
  using conditional = typename impl::conditional< B, T, F >::type;
}

这留下了我应该提供什么接口(interface)/API 的问题。我看到提供包装器的一个优点:它可以防止用户错误。参见例如 this 问答。

为了保持现有界面，我看到以下几点:

• 一致性。这就是类型特征，基本上每个人都在使用
• 转换器的分离和转换的结果。您可以将转换器作为一种类型传递，如果是上面的 whatever，这将不再可能。
• 通过避免特化所需的 impl 解决方案来减少代码。

我想听听支持或反对提供"new"界面的争论，而不仅仅是“我更喜欢第二种方法”这样的意见。我有兴趣了解需要一种或另一种方法或无法工作/扩展的情况。

老实说，问题主要是我缺乏使用模板类型定义的经验，所以如果你有一些实际经验，请分享它的优点和缺点，以及我是否应该考虑 typename transform<...>::type API 在 C++11 中是否已过时。

Answer 1

我总是这样做:

1. 在一些命名空间(impl、detail 等)中有执行实际工作的类。
2. 在外部，使用模板别名来清理调用代码。

例如，如果我要重写 std::remove_reference，我会这样做:

namespace detail {
    template <typename T> struct remove_reference
    {
        using type = T;
    };
    template <typename T> struct remove_reference<T&>
    {
        using type = T;
    };
    template <typename T> struct remove_reference<T&&>
    {
        using type = T;
    };
}

template <typename T>
using remove_reference = typename detail::remove_reference<T>::type;

我没有编译上面的代码，所以如果我打错了，请不要拍我。

一个好处是调用站点更加清晰。一个潜在的缺点是，如果您正在编写高阶泛型代码并依赖于某个类型函数内部存在的::type，例如

template <template <typename...> class F, typename... Ts>
using apply = typename F<Ts...>::type;

尽管您可以将 using 行更改为

using apply = F<Ts...>;

没有任何伤害。这一切实际上都取决于您的其余代码在做什么。如果您的类型函数需要具有特定接口(interface)(::type 或::value)，那么您需要符合它们。