std::visit(&f, something);
这是无效的,因为f
不是一个单一的函数。&f
说“给我一个指针f
". But f
不是一回事;它是三个函数,它们碰巧共享一个名称,并具有三个单独的指针。
std::visit([](auto&& x) {f(x);}, something);
这将创建一个基于模板的闭包,该模板生成在编译时进行分派的代码。实际上,它的工作原理就像我们所做的一样
void f(A a) {
std::cout << a.name << std::endl;
}
void f(B b) {
std::cout << b.type << std::endl;
}
void f(C c) {
std::cout << c.age << std::endl;
}
struct F {
template<typename T>
void operator()(T x) {
f(x);
}
};
int main() {
std::variant<A, B, C> something{B{}};
std::visit(F(), something);
}
这将迫使 C++ 编译器在模板扩展期间生成类似的内容
void f(A a) {
std::cout << a.name << std::endl;
}
void f(B b) {
std::cout << b.type << std::endl;
}
void f(C c) {
std::cout << c.age << std::endl;
}
struct F {
void operator()(A x) {
f(x);
}
void operator()(B x) {
f(x);
}
void operator()(C x) {
f(x);
}
};
int main() {
std::variant<A, B, C> something{B{}};
std::visit(F(), something);
}
如果你想消除 lambda 包装器,你需要一个可以作为参数传递的可调用对象,而函数指针是不够的,因为函数指针无法进行重载决策。我们总是可以显式地创建一个函子对象。
struct F {
void operator()(A a) {
std::cout << a.name << std::endl;
}
void operator()(B b) {
std::cout << b.type << std::endl;
}
void operator()(C c) {
std::cout << c.age << std::endl;
}
};
int main() {
std::variant<A, B, C> something{B{}};
std::visit(F(), something);
}
您是否认为这种方法比以前的方法更干净取决于您。一方面,它更像是传统的 OOP 访问者模式,因为我们有一个对象进行访问。另一方面,如果我们能够通过name一个函数并且让 C++ 理解我们的意思,但这要么需要特殊的 C++ 语法std::visit
或以多方法形式运行时调度。不管怎样,这不太可能很快发生,或者根本不可能发生。