C ++如何有条件地初始化模板类对象？

Question

我有一个模板类

template <typename T>
class myClass
{
   T variable;
....
};

我想创建一个 myClass 的对象，根据某些条件，该对象应该包含一个字符串或 int 。我如何有条件地初始化如下：

if (condition1)
  myClass<userDefinedType1> x;
else
  myClass<userDefinedType2> x;

我不认为我上面写的代码是可能的，但问题是在编译时我不知道类型应该是userDefinedType1 还是userDefinedType2。当我只能在运行时根据用户输入知道类型时，如何初始化模板类对象？

Answer 1

如果直到运行时才知道问题的类型，那么您的选择是有限的。

如果可能的实例化数量很少/简单并且您使用c++17 或更高版本，则一种选择是只使用std::variant：

using MyClass = std::variant<std::monostate, myClass<userDefinedType1>,myClass<userDefinedType2>>;

auto v = MyClass{}; // create one without a value to start

if (condition) {
  v = myClass<userDefinedType1>{};
} else {
  v = myClass<userDefinedType2>{};
}

std::variant 负责确保不发生不正确的访问（这可以防止违反严格别名的行为），并且它还将确保为正确实例化的类型调用非平凡的析构函数。这可以很容易地与visit 一起使用，假设需要调用的函数是同构定义的，因为您可以使用带有auto 参数的lambda，它将选择正确的类型：

std::visit([](auto& cls){
    cls.do_something();
}, v);

另一个可以使用的实用程序是std::any，用于类似目的：

auto v = std::any{};

if (condition) {
  v = myClass<userDefinedType1>{};
} else {
  v = myClass<userDefinedType2>{};
}

std::any 的缺点是访问内部类型要复杂得多，需要使用std::any_cast 进行轮询。仍然可行，但不是很好

---

如果你的模板可能有一些你可以擦除的基类，polymorphism 是一个选择。这可能不适用于所有设计，但如果确实如此，您可以在构造类时简单地使用std::unique_ptr 将实例保存到基类。

class myClassBase {
    ...
    virtual auto common_api(...) -> void = 0;
    ...
};
template <typename T>
class myClass : public myClassBase {
    ...
    auto common_api(...) -> void override { ... }
    ...
};

...

auto v = std::unique_ptr<Base>{};
if (condition) {
    v = std::make_unique<myClass<userDefinedType1>>(...);
} else {
    v = std::make_unique<myClass<userDefinedType2>>(...);
}

---

最后一个真正的选择是执行某种形式的手动类型擦除，您可以在其中创建一个擦除模板参数的包装类。此解决方案不是通用的，并且将高度特定于类本身，以了解如何擦除它。这可能涉及一些简单的东西，例如擦除实现中的类型的多态包装器，或者它可能更复杂，例如执行更多工作的绑定函数指针。

Answer 2

啊，模板元编程 (TMP) 的疯狂世界。由于constexpr 等原因，现在变得容易多了，但是要对班级成员进行编程，您仍然需要走老路。

您必须通过从基类继承来生成您的成员。

该基类可以是一个模板，包括一个花哨的条件 TMP 构造。您可以在一些标准库类中看到这一点。

嗯，你想要 same 数据成员 (x)，只是有不同的类型。好吧，这更容易：将其设为T2 类型。这可以使用模板的东西生成。像这样的：

using T2 = std::conditional_t<condition1, userDefinedType1, userDefinedType2>;
myClass<T2> x;

在编译时我不知道。

嗯，那是另一个故事了。您不能在编译时更改生成的代码except。

你想要一个变量x 可以容纳两种类型中的任何一种吗？

这可以使用面向对象的技术，具有具有不同派生类型的通用多态基类。

或者，您可以使用std::variant。

Ozger 的回答显示的（原始）union 基本上是同一想法的低级未经检查的版本。在旧版本的 C++ 中，这样的 union 无法保存具有构造函数和析构函数的类型，但现在它们可以了，尽管您需要付出很多低级的努力。它基本上是使编写variant 更简单的语言后端。

Answer 3

您可以使用联合。

union U {
    myClass<userDefinedType1> a;
    myClass<userDefinedType2> b;
};

U u;
if (condition1)
  u.a = myClass<userDefinedType1>();
else
  u.b = myClass<userDefinedType2>();

如 cmets 中所述，仅当 myClass 具有普通析构函数时才会编译，包括将破坏 myClass 中 T 的隐式析构函数。

Answer 4

除非您需要存储x 以供将来使用， 你也可以制作适用于x模板的代码，然后你的分支看起来像：

template <typename T> void foo(T);

// ...

if (condition1) {
    myClass<userDefinedType1> x;
    foo(x);
} else {
    myClass<userDefinedType2> x;
    foo(x);
}

你甚至可以在函数模板中移动x，所以代码是：

template <typename T> void bar(T)
{
    myClass<T> x;
    // ...
}

// ...

if (condition1) {
    bar<userDefinedType1>();
} else {
    bar<userDefinedType2>();
}

如果您需要存储x 以供将来使用，您需要使用std::variant、多态基类或类型擦除。

Answer 5

我们不能只动态地创建类对象吗？像这样的：

if (condition1)
  myClass<userDefinedType1>* x = new myclass<userDefined1>;
else
  myClass<userDefinedType2>* x = new myclass<userDefined2>;

请告诉我这种方法有什么问题