c++ - C++ 中的模板化类分配

Question

这可能是一个非常基本的问题，但我搜索了一下却找不到任何东西。

我有一些看起来像这样的代码:

if(var == 1) {
  MyClass<A> x();
  x.doThing1();
  x.doThing2();
  x.doThing3();
  ...
  x.doThing10();
} else if(var == 2) {
  MyClass<B> x();
  x.doThing1();
  x.doThing2();
  x.doThing3();
  ...
  x.doThing10();
} else {
  MyClass<C> x();
  x.doThing1();
  x.doThing2();
  x.doThing3();
  ...
  x.doThing10();
}

我想做的是减少行数，例如:

// obviously non-working code
MyClass<auto> x;
if(var == 1) {
  x<A>();
} else if(var == 2) {
  x<B>();
} else {
  x<C>();
}
x.doThing1();
x.doThing2();
x.doThing3();
...
x.doThing10();

这样的事情可能吗？

Answer 1

您可以做一些事情。

在一般情况下，如果您不介意动态内存分配，您可以在虚拟基类中定义接口(interface)，在 MyClass 中实现接口(interface)，使用模板参数中需要的任何内容。沿着这些线的东西:

#include <memory>
#include <iostream>

class Base
{
public:
    virtual void doThing1() const = 0;
    virtual void doThing2() const = 0;
    virtual void doThing3() const = 0;
};

template <class T>
class MyClass: public Base
{
public:
    void doThing1() const {std::cout << T::foo << ".doThing1()" << std::endl;}
    void doThing2() const {std::cout << T::foo << ".doThing2()" << std::endl;}
    void doThing3() const {std::cout << T::foo << ".doThing3()" << std::endl;}
};
struct A {static const char foo = 'A';};
struct B {static const char foo = 'B';};
struct C {static const char foo = 'C';};

std::unique_ptr<Base> makeMyClassInstance(const int var)
{
    switch (var)
    {
        case 1: return std::make_unique<MyClass<A> >();
        case 2: return std::make_unique<MyClass<B> >();
        case 3: return std::make_unique<MyClass<C> >();
        default: throw std::runtime_error("unsupported");
    }
}
int main()
{
    int var = 1;
    const auto x = makeMyClassInstance(var);
    x->doThing1();
    x->doThing2();
    x->doThing3();
}

如果var不是变量但在编译时可以知道，你可以有一个更激进的设计。在这种情况下，我将跳过 MyClass，但您会明白的:

#include <type_traits>
#include <iostream>
#include <tuple>

struct A{void foo() {std::cout << "A" << std::endl;}};
struct B{void foo() {std::cout << "B" << std::endl;}};
struct C{void foo() {std::cout << "C" << std::endl;}};

template <int I>
struct SelectType
{
    typedef typename std::remove_reference<decltype(std::get<I-1> (std::make_tuple(A(), B(), C())))>::type type;
};

template <int I, class T = typename SelectType<I>::type>
T makeMyClassInstance() {return T();}

int main()
{
    auto x1 = makeMyClassInstance<2>();
    x1.foo(); 
}