C++ 中的模板和预处理

Question

有人如何编译这段代码：

#include <iostream>
using namespace std;

enum E { A, B};

template< E x>
class C {
public:
    #if( x == A)
        static void foo() {
            cout << "A";
        }
    #elif( x == B)
        static void goo() {
            cout << "B";
        }
    #endif
};


int main() {
    C< A>::foo();
    C< B>::goo();

    return 0;
}

error: ‘goo’ is not a member of ‘C<(E)1u>’

我有两个大类，只有几行不同，所以我想制作枚举模板。问题是这行有using 关键字，所以我不知道该放什么。

有什么正确的方法吗？

PS> 我必须使用 C++03。

编辑：稍微澄清一下。我知道template<> 构造，但我不想使用它，因为这样我得到了很多代码重复。也许我可以以某种方式进行部分“模板实例化”（如果这是template<> 的正确术语）？

假设我有两个班级（我不会有更多）：

class A {
public:
//…a lot of code…
//few lines that differs in A and B
}

class B {
//…the same mass of code…
//few lines that differs in A and B
}

所以我决定在enum上制作模板：

enum E { A, B}
template< E>
class C{
//…common code…
}

现在我不知道如何处理这在 A 和 B 中不同的几行。我知道常见的方法是进行模板实例化，但是我会得到与 A 和 B 类完全相同的内容。

从 OOP 的角度来看，我应该对 A 和 B 使用常见的 Base。但问题是A 和B 已经是一样的了。它们仅与以下行不同：

using CanStoreKeyValue< QString, Request>::set;
using CanStoreKeyValue< QString, Response>::set;

其中Response 和Request 是类型定义。此外，在我的代码中，A 和 B 是同一个模板抽象类的子类。当然，他们使用不同的模板参数继承它。这以某种方式破坏了模板枚举的使用——编译器只是看不到某些虚拟方法不再是纯的。所以……这就是为什么我要问我在问什么。我认为预处理器可以通过#if-directives 与模板引擎进行交互（最后，它们都是编译时进程）。

Answer 1

您不能使用预处理器来实现您想要做的事情。您需要的是模板专业化：

enum E { A, B};

template< E x>
class C;

template <>
class C<A> {
public:
    static void foo() {
        cout << "A";
    }
};

template <>
class C<B> {
public:
    static void goo() {
        cout << "B";
    }
};

您更新后的问题仍然可以通过模板专业化解决：

enum E { A, B };

template< E x >
struct CanStoreKeyValueHelper;

template<>
struct CanStoreKeyValueHelper<A> {
    typedef CanStoreKeyValue< QString, Request>::set type;
};

template<>
struct CanStoreKeyValueHelper<B> {
    typedef CanStoreKeyValue< QString, Response>::set type;
};

template< E x>
class SuperPuperBigClass {
public:
    typedef typename CanStoreKeyValueHelper<x>::type set;
    ...
};

但不清楚你为什么不把它简化为：

template<class T>
class SuperPuperBigClass {
public:
    typedef typename CanStoreKeyValue<QString, T>::set set;
};

并用请求和响应类型实例化它

Answer 2

如果你不想要专业化，我想用SFINAE 来约束函数是一个选项（Live at coliru）：

template <E x>
class C {
public:
    template <E y = x>
    static typename std::enable_if<y == A>::type foo() {
        cout << "A";
    }

    template <E y = x>
    static typename std::enable_if<y == B>::type goo() {
        cout << "B";
    }
};

但如果代码重复是您唯一的问题，请使用专业化并将通用代码放在基类 (Live at Coliru) 中，这样会更简洁：

class C_base {};

template <E x>
class C : public C_base {};

template <>
class C<A> : public C_base {
public:
    static void foo() {
        cout << "A";
    }
};

template <>
class C<B> : public C_base {
public:
    static void goo() {
        cout << "B";
    }
};