C++17 std::variant 比动态多态慢吗？

Question

我正在关注 this blog并试图将动态多态性代码替换为使用 std::variant 和 std::visit。但是我无法让 std::variant + std::visit 比虚拟结构实现更好地工作。它大约慢 1.3-1.5 倍!(GCC 10.3 -O3 C++17)

用例如下。假设我们正在比较两个表的第 i 行和第 j 行。一个表可以有不同类型的列。假设我们可以访问列缓冲区。 我正在做的是测试，

def IndexEqual(Table:A, Table:B, int:i, int:j):
  for c in range(A.num_cols):
     if not A.column(c)[i] == B.column(c)[j]:
         return False
  return True

对于动态多态性，我对 int 和 float 有以下内容

struct Comp{
  virtual bool comp(size_t i, size_t j) const = 0;
};

struct CompI: public Comp {
  CompI(const int *data_1, const int *data_2) : data1(data_1), data2(data_2) {}

  const int *data1, *data2;
  bool comp(size_t i, size_t j) const override {
    return data1[i] == data2[j];
  }
};

struct CompF: public Comp {
  CompF(const float *data_1, const float *data_2) : data1(data_1), data2(data_2) {}

  const float *data1, *data2;
  bool comp(size_t i, size_t j) const override {
    return data1[i] == data2[j];
  }
};

bool IndexEqual1(const std::vector<Comp *> &comps, size_t i, size_t j) {
  for (auto &&a: comps) {
    if (!a->comp(i, j)) {
      return false;
    }
  }
  return true;
}

这被转换为 std::variant + std::visit 如下。

struct EqualToI {
  EqualToI(const int *data_1, const int *data_2) : data1(data_1), data2(data_2) {}
  const int *data1, *data2;
  bool comp(size_t i, size_t j) const {
    return data1[i] == data2[j];
  }
};

struct EqualToF {
  EqualToF(const float *data_1, const float *data_2) : data1(data_1), data2(data_2) {}
  const float *data1, *data2;
  bool comp(size_t i, size_t j) const {
    return data1[i] == data2[j];
  }
};

using var_type = typename std::variant<EqualToI, EqualToF>;

bool IndexEqual(const std::vector<var_type> &comps, size_t i, size_t j) {
  for (auto &&a: comps) {
    if (!std::visit([&](const auto &comp) {
      return comp.comp(i, j);
    }, a)) {
      return false;
    }
  }
  return true;
}

我在这里进行了基准测试 https://quick-bench.com/q/u-cBjg4hyQjOs6fKem9XSdW7LMs

有人可以解释为什么这个 std::variant + std::visit 选项比动态多态性方法慢吗？我的预期并非如此!我的方法和/或基准是否有问题？

Answer 1

使用variant不构成“静态多态”。它仍然是动态多态性，因为编译器不知道哪种类型将实际驻留在 variant 中。因此，有问题的代码必须尝试找出 variant 在运行时存储的内容，并且必须相应地调度这些调用。

请注意，您链接到的文章也 没有将其称为“静态多态性”。它强调它只是与虚函数不同的“运行时多态”形式。