std::variant反思。我如何知道分配了哪种类型的值 std::variant？

Question

我有一个名为 foo_t 的 class，它有一个名为 bar 的成员，它可以是 std::string、int、std::vector<double>，等等。我想问一下 foo_t 分配给了哪个类型 bar。我决定使用 std::variant.

我已经写了一个解决方案，但我不确定这是否是对 std::variant 的一个很好的使用。我不确定这是否重要，但我希望类型列表将来可能会变得更大。我做了一个枚举 class 来存储分配给哪个类型 std::variant 。我的第一个实现也可用于 wandbox:

#include <iostream>
#include <variant>
#include <vector>
#include <string>

enum foo_kind_t {
  double_list,
  name_tag,
  number,
  unknown
};

template <typename val_t>
struct get_foo_kind_t {
  constexpr static foo_kind_t value = unknown;
};

template <>
struct get_foo_kind_t<int> {
  constexpr static foo_kind_t value = number;
};

template <>
struct get_foo_kind_t<std::string> {
  constexpr static foo_kind_t value = name_tag;
};

template <>
struct get_foo_kind_t<std::vector<double>> {
  constexpr static foo_kind_t value = double_list;
};

class foo_t {

public:

  foo_t(): kind(unknown) {}

  template <typename val_t>
  void assign_bar(const val_t &val) {
    static_assert(get_foo_kind_t<val_t>::value != unknown, "unsupported assignment");
    kind = get_foo_kind_t<val_t>::value;
    bar = val;
  }

  foo_kind_t get_kind() {
    return kind;
  }

  template <typename val_t>
  val_t get_bar() {
    if (get_foo_kind_t<val_t>::value != kind) {
      throw std::runtime_error("wrong kind");
    }
    return std::get<val_t>(bar);
  }

private:

  foo_kind_t kind;

  std::variant<
    int,
    std::string,
    std::vector<double>
  > bar;

};

template <typename val_t>
void print_foo(foo_t &foo) {
    std::cout << "kind: " << foo.get_kind() << std::endl;
    std::cout << "value: " << foo.get_bar<val_t>() << std::endl << std::endl;
}

int main(int, char*[]) {

    // double_list
    foo_t b;
    std::vector<double> b_val({ 1.0, 1.1, 1.2 });
    b.assign_bar(b_val);
    std::cout << "kind: " << b.get_kind() << std::endl;
    std::cout << "value: vector size: " << b.get_bar<std::vector<double>>().size() << std::endl << std::endl;

    // name_tag
    foo_t d;
    std::string d_val("name");
    d.assign_bar(d_val);
    print_foo<std::string>(d);

    // number
    foo_t c;
    int c_val = 99;
    c.assign_bar(c_val);
    print_foo<int>(c);

    // unknown
    foo_t a;
    std::cout << a.get_kind() << std::endl;

    return 0;
}

这样做好吗？有没有更好的性能方法？有没有一种方法需要编写更少的代码？有没有不需要 C++17 的方法？

Answer 1

使用 std::variant::index 在运行时检查存储的类型。

Answer 2

如果你只需要问“Is this variant of type X ?”对于单个类型 X，那么我建议您更喜欢 std::holds_alternative over std::variant::index，因为这行代码更易于阅读，并且如果将来变体中类型的索引发生变化，则不必更新。

示例：

if (std::holds_alternative<X>(my_variant)) {
    std::cout << "Variant is of type X" << std::endl;
}

std::variant反思。我如何知道分配了哪种类型的值 std::variant？

std::variant reflection. How can I tell which type of value std::variant is assigned?

c++

reflection

std

variant

type-erasure