Question

我有一个有几个构造函数的类。根据通过argv传递给main（）的参数，我想在不同的构造函数之间切换。以下简化示例在“obj”更改为类的情况下工作正常，并且我使用例如obj1-＆gt; int和obj2-＆gt; double。但是，我需要更改以使用枚举运行以下代码？

#include<iostream>

using namespace std;

enum obj{obj1,obj2};

template <obj T>
class A
{
public:
  A(T);

private:
  T t_;
};

template<obj T>
A<T>::A(T )
{}

template<>
A<obj1>::A(obj1 t):t_(t) {cout<<"case 1"<< endl;}

template<>
A<obj2>::A(obj2 t):t_(t) {cout<<"case 2"<< endl;}

int main()
{
    obj test=obj1;
    A<obj> a(test);
    return 1;
}

感谢您的帮助！

编辑：很明显，代码在类型/值方面是错误的，但哪种机制可能类似于构造函数的这种切换？

Answer 1

你必须专注于类型，而不是价值观。如果您在编译时知道该值，则可以使用boost::mpl::int_来执行此操作。如果你不这样做（就像你的情况一样），你将不得不忍受普通的if。

Answer 2

你正在接近这个问题。模板在编译时实例化，因此您无法根据运行时存在的值选择特化。除了代码中的其他错误之外，此解决方案将无效。

此类问题的常见解决方案（基于参数创建不同的对象）是abstract factory pattern。这意味着您将条件构造逻辑移动到工厂类并使用虚方法来避免在调用端编写不同代码的需要（基本上您使用多态）。

Answer 3

我认为以下是你打算做的事情：

#include<iostream>

enum obj{obj1,obj2};

template<obj>
class A
{
public:
    A();

private:
    obj t_;
};

template<obj x>
A<x>::A() : t_(x){}

template<>
A<obj1>::A() : t_(obj1){ std::cout << "obj1\n"; }

template<>
A<obj2>::A() : t_(obj2){ std::cout << "obj1\n"; }

int main()
{
    const obj x = obj1; //  can only be used as the template argument below because it's a compile time constant
    A<x> a;

    return 0;
}

但是，只有当你想要“切换”编译时常量时，这才有效，而听起来你不这样做。您需要使用运行时条件（if，switch等）。

Answer 4

你必须做这样的事情：

enum E
{
    A,
    B
};

template<E e>
struct A
{
};

template<>
struct A<E::A>
{
};

template<>
struct A<E::B>
{
};

int main()
{
    A<E::B> ab;
}

构造函数模板

4 个答案: