Question

我正在编写一些基准代码的包装器，并希望在已经模板化的函数中为每个模板化的类类型执行相同的代码。

有基准类：

template<class T>
class Benchmark : public Interface, public T {
   virtual void Execute();
}

作为T类，我想使用一种基本上只用于初始化类变量的类型，例如

template<class S>
struct GenericBench {
    GenericBench();
    S var1, var2, var3;
};

现在的问题是：在某种程度上可以为GenericBench的每个突变定义一个专门的函数执行这种类的继承传播吗？

template<>
void Benchmark<GenericBench>::Execute() {
   // my benchmark code
}

主要电话会看起来像这样：

myBench->Execute<GenericBench<int>>();

Answer 1

以下代码用g ++编译和链接

struct Interface { };

template<class T>
class Benchmark: public Interface, public T {
public:
    virtual ~Benchmark() { }
    virtual void Execute();
};

template<class S>
struct GenericBench {
    GenericBench() { }
    S var1, var2, var3;
};

// Specialization of the class   
template<class S>
class Benchmark<GenericBench<S> >: public Interface, public GenericBench<S> {
public:
    virtual ~Benchmark() { }
    virtual void Execute() {
        // do things
    }
};

int main(int argc, char **argv) {
    Benchmark<GenericBench<int> > myBench;

    myBench.Execute();
}

Answer 2

既然你说你想根据你正在处理的类型定义专门的回答...制作功能模板然后专门化它会有所帮助。

以下是一个例子（抱歉没有使用你提供的例子..我只想表明这种方法。让我知道它是否适合你）

template <class S> class myData {
public:
};
namespace mySpecializedFunction {
    template<class P> void someFunction(P check) {std::cout<<"3333\n";return;}
    template<> void someFunction(myData<int> check) {std::cout<<"4444\n";return;}
    template<> void someFunction(myData<float> check) {std::cout<<"5555\n";return;}
}


template <class T> class myClass: public T {
public:
    template <class Q> void someFunction( Q check) {     mySpecializedFunction::someFunction(check); return ; }

};

并像这样使用它......

myData<int> d1;
myData<float> d2;

myClass< myData<int> > c1;
c1.someFunction(d1);

myClass< myData<float> > c2;
c2.someFunction(d2);

在专用模板函数中使用通用模板类

2 个答案: