专门为一种类型的模板类成员函数

Question

我有一个模板类,它有很多功能,但本质上是一个矢量类.我想为bool类型添加一个函数.

#include <vector>
template <typename T>
class reflected{
    private:
        T*dev_;
        T*host_;
        ar_size size;
        reflected<T>& operator=(reflected<T>& rhs);//do not impliment.  assign not allowed.
        reflected( reflected<T>& old);  //do not impliment. Copy not allowed.
    public:
        reflected():size(0L),dev_(NULL),host_(NULL){}
        reflected(ar_size n):size(n),dev_(NULL),host_(NULL){init();}
        reflected(const T*x,ar_size n):size(n),dev_(NULL),host_(NULL){init();set(x);}
        ~reflected();
        void init();
        void init(ar_size n);
        void init(const T*x,ar_size n);
        void set(const T * x);
        void setat(ar_index i, T x);
        const T getat(ar_size i);
        const T * devPtr();
        const T operator [](const ar_index i);
        ar_size length(){return size;}
};

我想vector<ar_index> reflected<bool>::which()在反射类的特殊情况下添加一个函数,这是唯一有意义的情况.做这个的最好方式是什么.编译器似乎不喜欢添加which()来反映并仅为bool定义它.

Answer 1

您可以在类模板中定义它

template <typename T> struct id { typedef T type; };

template <typename T>
class reflected{
    private:
        /* ... */
        vector<ar_index> which(id<bool>) { 
          /* ... */
        }
    public:
        /* ... */
        vector<ar_index> which() { return which(id<T>()); }
};

如果您调用未给出正确定义which的reflected<T>for,T则会出现编译时错误.

Answer 2

如果你只想添加一个问题，你可以将继承与特化结合起来：

template <typename T>
class reflected_base { 
    // your current 'reflected' contents go here
}; 

template <typename T>
class reflected : public reflected_base { };

template <>
class reflected<bool> : public reflected_base {
    vector<ar_index> which();
};

这种方法的缺点是您必须为每个专门化重新实现某些操作（析构函数、复制构造函数等）。另一种选择是：

template <typename T>
class specialized_reflected { };

template <>
class specialized_reflected<bool> {
public:
    vector<ar_index> which();
};

template <typename T>
class reflected : public specialized_reflected<T> {
    // your current 'reflected' contents go here
};

不过，从属名称查找存在潜在问题。第三种选择（可能也是我会选择的一种）是使用非成员函数：

vector<ar_index> which(reflected<bool>&);