Question

我正在尝试解决以下问题。我有一个向量（实际上是一个自定义结构，但是矢量是这个问题的足够替代品）指向自定义类A的指针。类A实际上可以存储type_a指针或type_b指针（这些类型非常不同并且彼此不相关）。现在通过保持两者来实现，将它们设置为NULL，然后稍后使用一堆if/else语句来检查它是哪种类型并执行适当的操作。

class A {
public:
  A() : p1(NULL), p2(NULL) {}

  type_a * p1;
  type_b * p2;
};

std::vector<A *> v;

...

if (v[0]->p1 != NULL) { /* do this */ }
else if (v[0]->p2 != NULL) { /* do that */ }

我计划添加更多指向类A的指针，因此上面的内容开始变得麻烦。我目前正在努力解决的问题是使用boost::variant代替：

class A {
public:
  boost::variant<type_a*, type_b*> p;
};

我遇到的问题是，我的一个操作涉及调用一个函数，该函数会根据我所拥有的p类型为变量赋值。这就是现在的情况，在上述process_stuff语句之一中调用了适当的if/else函数：

class B { /*...*/ };

void process_stuff(type_a * p, B * b) {
  b->m_var = p->fn1();
}

void process_stuff(type_b * p, B * b) {
  b->m_var = p->fn2();
}

我无法使用boost::static_visitor，因为（据我所知）我不能将非变量类型作为二元访问中的参数，也不能使用非常量operator()使第二个变量成为访问者类的成员，并使用一元访问在operator()内进行修改。所以我很困惑如何将上述process_stuff函数与boost::variant一起转换。

顺便说一下，我没有加入boost::variant并会采取其他解决方案。

Answer 1

你只需要有状态的访客。我从模糊的记忆中输入这个，确切地说是游客的样子，但你应该能够解决我犯的任何错误。

class process_stuff_visitor : public boost::static_visitor<void> {
  B* m_b;

public:
  process_stuff_visitor(B* b) : m_b(b) {}
  void visit(type_a* a) const { m_b->m_var = a->fn1(); }
  void visit(type_b* b) const { m_b->m_var = b->fn2(); }
};
// actual processing:
boost::apply_visitor(v[0], process_stuff_visitor(the_b));

或者，由于您指定了B的同一成员，因此您只需提取值生成部分。

struct generate_stuff_visitor : public boost::static_visitor<TypeOfMVar> {
  TypeOfMVar visit(type_a* a) const { return a->fn1(); }
  TypeOfMVar visit(type_b* b) const { return b->fn2(); }
};
the_b->m_var = boost::apply_visitor(v[0], generate_stuff_visitor());

Answer 2

一种非常通用的面向对象的方式来做你想做的事情（如果我理解你的话）是为类型a和b（以及你想要的任何其他类型）创建一个虚拟基类，它定义了一个纯虚方法。这个方法将为每种类型返回不同的东西（例如，type_b :: method可以返回'b'，而type_a :: method可以返回'a'），所以当你在未指定的类型上调用方法时，你会被告知它是什么类型。

从那里，你可以使用识别方法的返回值作为switch语句的主语，或者使用其他一些传统的控制结构来调用正确的行为。

变量与非变体类型的变量交互

2 个答案: