Question

我正在寻找更好的方法。我有一大堆代码需要处理包含不同类型的几个不同对象。我的结构看起来像这样：

class Base
{
    // some generic methods
}

template <typename T> class TypedBase : public Base
{
    // common code with template specialization
    private:
        std::map<int,T> mapContainingSomeDataOfTypeT;
}
template <> class TypedBase<std::string> : public Base
{
    // common code with template specialization
    public:
        void set( std::string ); // functions not needed for other types
        std::string get();
    private:
        std::map<int,std::string> mapContainingSomeDataOfTypeT;
        // some data not needed for other types
}

现在我需要添加一些仅适用于衍生类之一的附加功能。特别是std :: string派生，但类型实际上并不重要。这个课程足够大，我宁愿不复制整个东西只是为了专门化它的一小部分。我需要添加一些函数（和访问器和修饰符）并修改其他几个函数的主体。有没有更好的方法来实现这一目标？

Answer 1

在模板定义中强加另一个间接级别：

class Base
{
    // Generic, non-type-specific code
};

template <typename T> class TypedRealBase : public Base
{
     // common code for template
};

template <typename T> class TypedBase : public TypedRealBase<T>
{
    // Inherit all the template functionality from TypedRealBase
    // nothing more needed here
};

template <> class TypedBase<std::string> : public TypedRealBase<T>
{
    // Inherit all the template functionality from TypedRealBase
    // string-specific stuff here
}

Answer 2

你不必专门研究整个班级，只需要你想要的东西。适用于GCC＆amp; MSVC：

#include <string>
#include <iostream>

class Base {};

template <typename T>
class TypedBase : public Base
{
public:
    T get();
    void set(T t);
};

// Non-specialized member function #1
template <typename T>
T TypedBase<T>::get() 
{
   return T();
}

// Non-specialized member function #2
template <typename T>
void TypedBase<T>::set(T t) 
{
    // Do whatever here
}

// Specialized member function
template <>
std::string TypedBase<std::string>::get() 
{
    return "Hello, world!";
}

int main(int argc, char** argv) 
{
    TypedBase<std::string> obj1;
    TypedBase<double> obj2;
    std::cout << obj1.get() << std::endl;
    std::cout << obj2.get() << std::endl;
}

关于类的部分模板特化

2 个答案: