混合别名和模板特化

Question

我正在努力寻找最好的方法来拥有一种“对象”，它可以是专门的，也可以“链接”到另一种类型。

例如，您不能专门化一个类以使其成为简单的 int，并且您不能使用关键字 using 来专门化类。

我的解决方案如下：

template<class Category, Category code>
struct AImpl
  {};

template<class Category, Category code>
struct AHelper
  {
  using type = AImpl<Category, code>;
  };

template<class Category, Category code>
using A = typename AHelper<Category, code>::type;

template<int code>
void doSomething(A<int, code> object)
  {
  }

template<>
struct AImpl<int, 5>
  { 
  double a; 
  };

template<>
struct AImpl<int, 6>
  { 
  int b; 
  double c;
  };

template<>
struct AHelper<int, 7>
  {
  using type = int;
  };

template<class Category, Category code>
struct Alternative {};

template<int code>
void doSomethingAlternative(Alternative<int, code> object)
  {
  }

这可行，但您需要在 doSomething 中指定代码参数，我想避免这种情况。

例如：

A<int,7> a7; // This is equivalent to int
a7 = 4;
A<int, 5> a5; // This is equivalent to AImpl<int,5>
a5.a = 33.22;
doSomething(a5); // This does not compile
doSomething<5>(a5); // This compiles but is bulky
Alternative<int,0> alt0;
doSomethingAlternative(alt0); // This compiles and is not bulky
                              // but you're forced to use class
                              // specializations only

有没有办法实现我想要的？可以同时更改 doSomething 或 A 实现。

Answer 1

如果您尝试根据调用它的类型自定义doSomething 的行为，您不能让编译器从AHelpr::type 推导出东西（如之前的answered）。但是您可以通过以traits 的形式提供自定义点来告诉它它需要知道什么。例如：

template<typename T>
void doSomething(T& object)
{
    auto code = SmthTriats<T>::code;
}

鉴于SmthTriats 的专业化能力，这是高度可扩展的：

template<typename> struct SmthTriats;

template<typename Category, Category code_>
struct SmthTriats<AImpl<Category, code_>> {
    static constexpr auto code = code_;
};

template<>
struct SmthTriats<int> {
    static constexpr auto code = 7;
};

traits 类也允许在您的模块之外进行自定义。客户端代码只需要使用他们自己的类型专门化 SmthTriats，只要他们尊重你为你的 trait 制定的合同，你的代码就会为他们工作。