C++ 中的动态调度 - 更好的语法

Question

我想在 C++ 中有一个 dynamic_call 功能。它应该触发重载决议并根据参数的动态类型调用目标类（访问者）上最具体的函数。它应该替换访问者模式，并且应该像 C# 中的动态关键字一样工作。 我把到目前为止我得到的东西贴在下面。我不想在调用方声明通用 lambda，而是在动态调用的实现上声明它以使其更易于使用。这可能吗？

#include <iostream>

struct Base { virtual ~Base() = default; };
class A : public Base {};
class B : public Base {};

template <class... Ts>
class dynamic_call {
public:
    template <class F, class Arg>
    static void call(F& func, Arg& a) {
        call_impl<F, Arg, Ts...>(func, a);
    }
private:
    template <class F, class Arg>
    static void call_impl(F& /*func*/, Arg& /*a*/) {
        //end of recursion => nothing more to be done
    }
    template <class F, class Arg, class T, class... R>
    static void call_impl(F& func, Arg& a) {
        T* t = dynamic_cast<T*>(&a);
        if(t) {
            func(*t);
        }
        call_impl<F, Arg, R...>(func, a);
    }
};

using namespace std;
struct Visitor {
    void Visit(A&) { cout << "visited for a" << endl; }
    void Visit(B&) { cout << "visited for b" << endl; }
};

int main(int /*argc*/, char */*argv*/[])
{
    Visitor v;
    auto func = [&v](auto& a) { v.Visit(a); };

    A a;
    dynamic_call<A, B>::call(func, a);

    B b;
    dynamic_call<A, B>::call(func, b);

    {
        Base& base(a);
        dynamic_call<A, B>::call(func, base);
    }
    {
        Base& base(b);
        dynamic_call<A, B>::call(func, base);
    }

    return 0;
}

我想这样调用它而不需要添加通用 lambda。

dynamic_call<A,B>::call(v, a);

Answer 1

这里有一些想法，我不确定你的要求是什么，所以它们可能不适合：

1. 将Visit 更改为operator()。然后调用语法根据您的需要减少到dynamic_call<A,B>::call(v, a);。当然，这只有在访问者的界面可以改变时才有可能。

2. 将call_impl 中的func(*t) 更改为func.Visit(*t)。然后调用者再次可以使用dynamic_call<A,B>::call(v, a); 并且无需更改访问者的界面。然而，每个使用 dynamic_call 的访问者现在都需要将 Visit 定义为访问者方法。我认为operator() 更干净并且遵循通常的模式，例如更多标准库中的谓词。

我不是特别喜欢其中任何一个，因为调用者总是必须知道访问者中可能存在的重载，并且必须记住使用dynamic_call。所以我建议解决访问者结构中的所有问题：

1. struct Visitor {
       void Visit(A&) {
           cout << "visited for a" << endl;
       }
       void Visit(B&) {
           cout << "visited for b" << endl;
       }
       void Visit(Base& x) {
           dynamic_call<A,B>::call([this](auto& x){Visit(x);}, x);
       }
   };
   

   这可以用v.Visit(a)、v.Visit(b) 和v.Visit(base) 调用。这样Visitor 的用户就不需要了解不同派生类的不同行为。

2. 如果你不想修改Visitor，那么你可以通过继承添加重载：

   struct DynamicVisitor : Visitor {
       void Visit(Base& x) {
           dynamic_call<A,B>::call([this](auto& x){Visit(x);}, x);
       }
   };
   

这些点可以组合，例如：

struct Visitor {
    void operator()(A&) {
        cout << "visited for a" << endl;
    }
    void operator()(B&) {
        cout << "visited for b" << endl;
    }
    void operator()(Base& x) {
        dynamic_call<A,B>::call(*this, x);
    }
};

用作v(a)、v(b) 和v(base)。