Question

我有一个与模板类实现设计相关的问题。

模板AT可以专门用于模板参数A1和A2：

AT<A1> a;

or

AT<A2> a;

模板有一个可以使用B1和B2类的功能。具体来说，当模板专用于A1类时，该函数应使用B1，对于A2，应使用B2。例如：

template< class T > class AT : public A
{
  int size;

  public:
    int f()
    {
        if ( dynamic_cast<A1*> this != 0 ) {
            size = sizeof( B1 );
        }
        else {
            size = sizeof( B2 );
        }
    }

    ...
};

由于B1和B2是与内部A1和A2实现相关的类，因此最好不要让最终用户了解它们的存在，因此模板的专业化如

AT<A1, B1> a;

是不可接受的。

设计此类模板类的最佳方法是什么，并允许基于模板专用的类进行内部区分？

谢谢！

Answer 1

您可以创建一个简单的类型特征来映射它的类型：

template <typename T>
struct B_type;           // Generic type mapping declaration (undefined)
template <>
struct B_type<A1> {      // Mapping of A1 -> B1
   typedef B1 type;
};
template <>
struct B_type<A2> {      // Mappint of A2 -> B2
   typedef B2 type;
};

然后在内部使用它：

template <typename T>
int AT<T>::f() {
   return sizeof( typename B_type<T>::type );
}

Answer 2

在更简单的情况下，您可以使用类型特征。

如果你需要更复杂的东西，你可以使用私有/受保护的继承，或者只是创建专门的对象（感谢David指出不可能使用成员类的事实），它具有对A1和A2的明确特化，以及选择正确的功能。

template<> class sizeofFunc<A1>
{
    public:
        static int getSize(T obj) {
            return sizeof(B1);
        }
};

template<> class sizeofFunc<A2>
{
  public:
      static int getSize(T obj) {
          return sizeof(B2);
      }
};

template< class T > class AT : public A, private sizeofFunc<T>
{
  int size;

  public:
    int f()
    {
        size = getSize(something);
    }

    ...
};

基于参数的模板内部类

2 个答案: