Question

如何在不使用宏的情况下处理Object :: func（）定义的重复？

template <int N> struct Object {};

template <> struct Object<0> {
    // special stuff
    void func();
};

template <> struct Object<1> {
    // special stuff
    void func();
};

template <> struct Object<2> {
    // special stuff
    void func();
};

template <int N> struct Thing {};

void Object<0>::func() {
    Thing<0> a;
    // do stuff with a
}

void Object<1>::func() {
    Thing<1> a;
    // do exact same stuff with a
}

void Object<2>::func() {
    Thing<2> a;
    // do exact same stuff with a
}

私有继承，其中base具有模板int N？元模板的东西？ CRTP？我无法弄清楚。注意

// special stuff

意味着模板专业化是必要的 - 我只是没有展示它们是如何专业化的。我只显示了一个函数func（），它们与所有函数几乎完全相同。

Answer 1

使用继承可以避免公共代码的专门化。怎么样：

template <int N> struct ObjectBase {
  void func();
};

template <int N> struct Thing {};

template <int N>
void ObjectBase<N>::func() {
    Thing<N> a;
    // do stuff with a
}

template <> struct Object<0>: private ObjectBase<0> {
    // special stuff
};

template <> struct Object<1>: private ObjectBase<1> {
    // special stuff
};

template <> struct Object<2>: private ObjectBase<2> {
    // special stuff
};

Answer 2

对于您的问题，我的解决方案是使用模板模板参数来定义您的模板类，我觉得这是避免重复定义常见事物的方法。

以下是我刚刚在Visual Studio 2013中编码和测试的代码：

#include <iostream>

template <int N> struct Thing { int x; Thing() : x(N) {}; };

template <int N, template<int N> class T> struct Object { void func(); };

template <int N, template<int N> class T> void Object<N, T>::func()
{
    T<N> a;
    std::cout << a.x << std::endl;
};

int main()
{
    Object<0, Thing> obj0;
    Object<11, Thing> obj11;
    Object<22, Thing> obj22;
    obj0.func();
    obj11.func();
    obj22.func();
    return 0;
}

此代码将打印：

0 11 22

除模板参数外，具有相同功能的模板特化

2 个答案: