将由 boost::variant 聚合的类型的对象传递给接受该 boost::variant 的函数

Question

假设我有：

class TypeA { };
class TypeB { };
typedef boost::variant<TypeA, TypeB> Type;

1. 这没问题：

   void foo(Type t) { };
   
   int main(){
       A型a；
       foo(a);
   }
   

2. 这不能编译：

   void foo(Type &t) { };
   
   int main(){
       A型a；
       foo(a);
   }
   

   错误：

   <块引用>

   “Type&”类型引用的初始化无效从 “TypeA”类型的表达式

3. 这也无法编译：

   void foo(Type *t) { };
   
   int main(){
       A型a；
       foo(&a);
   }
   

   错误：

   <块引用>

   无法将参数“1”转换为“TypeA*”为“Type*”为“void” foo(类型*)'

有没有办法通过引用（如情况 2）或指针将 boost::variant 聚合的类型之一的实例传递给接受 boost::variant 的函数（如情况3）？

非常感谢！

Answer 1

1 中真正发生的情况：

TypeA a;
Type __temporary__(a);
foo(__temporary__);

2 或 3 中不会发生的情况：

TypeA a;
Type* __temporary__(&a);
  // this fails because there is no inheritance relationship
foo(__temporary__);

您有两种解决方案（对于非模板 foo）：

• 转换为 Type，然后获取对此的指针/引用，
• 创建一个 boost::variant 用于隐式转换以启动

第三种解决方案是更改 foo 本身，并将其设为模板。这取决于你想做什么。

Answer 2

聚合意味着 boost::variant 包含 TypeA 和 TypeB。事实并非如此。它包含 TypeA 或 TypeB。它更像是一个联合而不是一个结构。

您可以按值传递 TypeA，因为存在从 TypeA 到 Type 的隐式转换。

没有从 TypeA& 到 Type&（或 TypeA* 到 Type*）的隐式转换，并且不应该有不会的。想象一下，如果将对 TypeA 对象的引用传递给 foo() 并且 foo() 决定将其替换为 代码>TypeB 值。

在不知道 foo() 和 TypeA/TypeB 是什么的情况下，我无法给您更具体的建议，但也许您可以使用函数模板。即

template <typename T>
void foo(T& t) {}

或重载函数：

void foo(TypeA& t) {}
void foo(TypeB& t) {}