std::variant vs 指向 C++ 中异构容器基类的指针

Question

让我们假设下面这个类层次结构。

class BaseClass {
public:
  int x;
}

class SubClass1 : public BaseClass {
public:
  double y;
}

class SubClass2 : public BaseClass {
public:
  float z;
}
...

我想为这些类创建一个异构容器。由于子类是从基类派生的，我可以做这样的事情：

std::vector<BaseClass*> container1;

但从 C++17 开始，我也可以像这样使用std::variant：

std::vector<std::variant<SubClass1, SubClass2, ...>> container2;

使用其中一种的优点/缺点是什么？我也对表演感兴趣。

考虑到我将按x 对容器进行排序，并且我还需要能够找出元素的确切类型。我要去

1. 装满容器，
2. 按x排序，
3. 遍历所有元素，找出类型，相应地使用它，
4. 清空容器，然后循环重新开始。

Answer 1

std::variant<A,B,C> 包含一组封闭类型中的一个。您可以使用std::holds_alternative 检查它是否拥有给定的类型，或者使用std::visit 传递带有重载operator() 的访问者对象。可能没有动态内存分配，但是很难扩展：带有std::variant 的类和任何访问者类都需要知道可能的类型列表。

另一方面，BaseClass* 拥有一组无限的派生类类型。您应该持有std::unique_ptr<BaseClass> 或std::shared_ptr<BaseClass> 以避免内存泄漏的可能性。要确定是否存储了特定类型的实例，您必须使用dynamic_cast 或virtual 函数。此选项需要动态内存分配，但如果所有处理都是通过virtual 函数进行的，那么保存容器的代码不需要知道可以存储的类型的完整列表。

Answer 2

std::variant 的一个问题是你需要指定一个允许的类型列表；如果您添加未来派生类，则必须将其添加到类型列表中。如果需要更动态的实现，可以看std::any；我相信它可以达到目的。

我还需要能够找出元素的确切类型。

对于类型识别，您可以创建类似instanceof 的模板，如C++ equivalent of instanceof 所示。也有人说，使用这种机制的需要有时会暴露出糟糕的代码设计。

性能问题不是可以提前检测到的，因为它取决于使用情况：这是一个测试不同实现的问题，看看哪个更快。

考虑到这一点，我将按x对容器进行排序

在这种情况下，您声明变量public，因此排序完全没有问题；您可能需要考虑声明变量protected 或在基类中实现排序机制。

Answer 3

使用其中一种有什么优点/缺点？

与使用指针进行运行时类型解析和使用模板进行编译时类型解析的优点/缺点相同。有很多东西可以比较。例如：

• 如果滥用指针，可能会导致内存冲突
• 运行时解析有额外的开销（但也取决于您将如何准确使用这些类，如果是虚函数调用，还是只是普通成员字段访问）

但是

• 指针具有固定大小，并且可能比您的类的对象要小，因此如果您计划经常复制容器可能会更好

我也对表演感兴趣。

然后只需衡量您的应用程序的性能，然后再决定。推测哪种方法可能更快并不是一个好习惯，因为它在很大程度上取决于用例。

考虑到这一点，我将按 x 对容器进行排序 而且我还需要能够找出元素的确切类型。

在这两种情况下，您都可以找出类型。 dynamic_cast 在指针的情况下，holds_alternative 在 std::variant 的情况下。对于std::variant，必须明确指定所有可能的类型。在这两种情况下访问成员字段x 几乎相同（指针是指针解引用+成员访问，变体是get + 成员访问）。

Answer 4

在 cmets 中提到了通过 TCP 连接发送数据。在这种情况下，使用虚拟调度可能最有意义。

class BaseClass {
public:
  int x;

  virtual void sendTo(Socket socket) const {
    socket.send(x);
  }
};

class SubClass1 final : public BaseClass {
public:
  double y;

  void sendTo(Socket socket) const override {
    BaseClass::sendTo(socket);
    socket.send(y);
  }
};

class SubClass2 final : public BaseClass {
public:
  float z;

  void sendTo(Socket socket) const override {
    BaseClass::sendTo(socket);
    socket.send(z);
  }
};

然后你可以将指向基类的指针存储在一个容器中，并通过基类来操作对象。

std::vector<std::unique_ptr<BaseClass>> container;

// fill the container
auto a = std::make_unique<SubClass1>();
a->x = 5;
a->y = 17.0;
container.push_back(a);
auto b = std::make_unique<SubClass2>();
b->x = 1;
b->z = 14.5;
container.push_back(b);

// sort by x
std::sort(container.begin(), container.end(), [](auto &lhs, auto &rhs) {
  return lhs->x < rhs->x;
});

// send the data over the connection
for (auto &ptr : container) {
  ptr->sendTo(socket);
} 

Answer 5

不一样。 std::variant 就像一个具有类型安全性的联合。同一时间最多只能看到一个成员。

// C++ 17
std::variant<int,float,char> x;
x = 5; // now contains int
int i = std::get<int>(v); // i = 5;
std::get<float>(v); // Throws

另一个选项基于继承。根据您拥有的指针，所有成员都可见。

您的选择将取决于您是否希望所有变量都可见以及您想要什么错误报告。

相关：不要使用指针向量。使用shared_ptr的向量。

无关：我有点不支持新的 union 变体。旧的 C 风格联合的重点是能够访问它在同一内存位置拥有的所有成员。