Question

我想在不实现类的情况下使用lambdas实现多态访问者。我已经有了一个基础，但我正在为我的lambdas参数的类型推导而苦苦挣扎。

假设我有一些遗留代码库，决定使用类型标签作为多态类型，如下所示：

enum class ClassType
{
    BaseType = 0, TypeA, TypeB
};

class BaseType
{
public:
    virtual ~BaseType() {}
    ClassType getType() const
    { return type; }

protected:
    ClassType type;
};

class TypeA : public BaseType
{
public:
    static const ClassType Type = ClassType::TypeA;
    explicit TypeA(int val) : val(val)
    { type = ClassType::TypeA; }
    virtual ~TypeA() {}

    int val;
};

class TypeB : public BaseType
{
public:
    static const ClassType Type = ClassType::TypeB;
    explicit TypeB(std::string s) : s(s)
    { type = ClassType::TypeB; }
    virtual ~TypeB() {}

    std::string s;
};

我想要实现的是一个类似于std::variant访问者的访问者，它们看起来像这样：

std::vector<BaseType*> elements;
elements.emplace_back(new TypeA(1));
elements.emplace_back(new TypeB("hello"));

for (auto elem : elements)
{
    visit(elem,
        [](TypeA* typeA) {
            std::cout << "Found TypeA element, val=" << typeA->val << std::endl;
        },
        [](TypeB* typeB) {
            std::cout << "Found TypeB element, s=" << typeB->s << std::endl;
        }
    );
}

我迄今为止实现此类visit<>()函数的失败方法是以下代码：

template <typename T>
struct identity
{
    typedef T type;
};

template <typename T>
void apply_(BaseType* b, typename identity<std::function<void(T*)>&>::type visitor)
{
    if (b->getType() != T::Type)
        return;

    T* t = dynamic_cast<T*>(b);
    if (t) visitor(t);
}

template <typename... Ts>
void visit(BaseType* b, Ts... visitors) {
    std::initializer_list<int>{ (apply_(b, visitors), 0)... };
}

编译器抱怨它无法推导出T函数的模板参数apply_。

如何声明apply_的正确模板和函数签名以正确捕获lambda甚至其他callables？或者这样的事情甚至可能吗？

Answer 1

这是（不完整）解决方案，适用于任何具有一元，非重载，< strong>非模板化 operator()。首先，让我们创建一个帮助器类型别名来检索第一个参数的类型：

template <typename> 
struct deduce_arg_type;

template <typename Return, typename X, typename T> 
struct deduce_arg_type<Return(X::*)(T) const>
{
    using type = T;
};

template <typename F>
using arg_type = typename deduce_arg_type<decltype(&F::operator())>::type;

然后，我们可以在可变参数模板中使用 fold表达式来调用dynamic_cast成功的任何函数对象：

template <typename Base, typename... Fs>
void visit(Base* ptr, Fs&&... fs)
{
    const auto attempt = [&](auto&& f)
    {
        using f_type = std::decay_t<decltype(f)>;
        using p_type = arg_type<f_type>;

        if(auto cp = dynamic_cast<p_type>(ptr); cp != nullptr)
        {
            std::forward<decltype(f)>(f)(cp);
        }
    };

    (attempt(std::forward<Fs>(fs)), ...);
}

用法示例：

int main()
{
    std::vector<std::unique_ptr<Base>> v;
    v.emplace_back(std::make_unique<A>());
    v.emplace_back(std::make_unique<B>());
    v.emplace_back(std::make_unique<C>());

    for(const auto& p : v)
    {
        visit(p.get(), [](const A*){ std::cout << "A"; },
                       [](const B*){ std::cout << "B"; },
                       [](const C*){ std::cout << "C"; });
    }
}

ABC

live example on wandbox

Answer 2

假设您无法更改虚拟类，可以执行以下操作：

template <typename F>
decltype(auto) visitBaseType(BaseType& base, F&& f)
{
    switch (base.getType())
    {
        case ClassType::BaseType: return f(base);
        case ClassType::TypeA: return f(dynamic_cast<TypeA&>(base));
        case ClassType::TypeB: return f(dynamic_cast<TypeB&>(base));
    }
    throw std::runtime_error("Bad type");
}

template<class... Ts> struct overloaded : Ts... {
    using Ts::operator()...;

    overloaded(Ts... ts) : Ts(ts)... {}
};
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

template <typename ... Fs>
decltype(auto) visit(BaseType& base, Fs&&... fs)
{
    return visitBaseType(base, overloaded(fs...));
}

Demo

Answer 3

我并不总是这么说，但这可能是Boost.Preprocessor的工作。您有一个与枚举列表对应的类类型列表，每个实例通过getType()标识自己。所以我们可以使用它：

#include <boost/preprocessor/seq/for_each.hpp>

#define CLASS_LIST (TypeA) (TypeB)

// just take one visitor
template <class Visitor>
void visit(Base* ptr, Visitor f) {
    switch (ptr->getType()) {
    #define CASE_ST(r, data, elem) case elem: f(static_cast<elem*>(ptr)); break;
    BOOST_PP_SEQ_FOR_EACH(CASE_ST, ~, CLASS_LIST)
    #undef CASE_ST
    default: f(ptr); // in case you want an "else"
                     // this is optional
    }
}

那将预处理成：

switch (ptr->getType()) {
case TypeA: f(static_cast<TypeA*>(ptr)); break;
case TypeB: f(static_cast<TypeB*>(ptr)); break;
default: f(ptr);
}

lambdas

3 个答案: