是否可以将通用 lambda 作为非模板参数传递

Question

我有一个玩具示例，我想在架构上进行修改以删除 Processor 对 EmitterT 的类型依赖性：

#include <iostream>
#include <utility>

using namespace std;

struct Emitter {
    void e(int) { cout << "emitting int\n";}
    void e(double) { cout << "emitting double\n";}
    void e(char*) { cout << "emitting char*\n";}
    void e(const char*) { cout << "emitting const char*\n";}
};

template <typename EmitterT>
struct Processor {

    Processor(EmitterT e) : e_{e} {}

    template <typename T>
    void process(T&& value) {
        cout << "some processing... ";
        e_(std::forward<T>(value));
    }

    EmitterT e_;

};

template<typename Emitter_>
Processor<Emitter_> makeProcessor(Emitter_ e) { return Processor<Emitter_>(e);}

int main() {
    Emitter em;
    auto p = makeProcessor([&em](auto v){em.e(v);});


    p.process(1);
    p.process("lol");
    return 0;
}

动机

我想将负责利用处理结果的部分与处理本身分离。 Emitter类结构给了我，所以我必须支持重载函数。

我想将 lambda 函数传递给将要使用它的处理器。有点像回调机制，但它必须是通用 lambda，才能支持重载。

我尝试过的：

我写的例子有效，但它依赖于Emitter 类型作为模板参数。我不喜欢根据Emitter 更改Processor 类型。它也具有传染性，我有一个真正的Processor 层次结构和Emitter 传播就像const 或更糟。

在阅读https://stackoverflow.com/a/17233649/1133179 之后，我尝试以成员身份使用以下结构：

struct EmitterC {
    template<typename T>
    void operator()(T value) { }
};

但是当将 Emitter 用作普通参数时，我无法想出一种方法来在 Processor 之后推迟实现 Emitter。它通过前向声明和引用EmitterC& 解决，但它只支持一个发射器定义。我能想到的唯一方法是删除 lambda，并在 EmitterC 中为我期望在 Emitter 中的每种类型进行虚拟重载，并将其用作基类。

那么，有没有办法将（通用）lambda 作为参数传递，使Processor 类型不依赖于Emitter？

我仅限于 c++14，但如果有更好的支持，我也对更现代的标准感兴趣。

Answer 1

这个最简单的解决方案是让Emitter成为process的参数：

struct Processor {
    template <typename T, typename EmitterFn>
    void process(T&& value, EmitterFn emit) {
        cout << "some processing... ";
        emit(std::forward<T>(value));
    }

};

---

但是，如果它必须是 Processor 的成员并且您可以枚举可能的函数签名，则可以使用某种类型擦除。 std::function 或建议的 std::function_ref 将不起作用，因为它们只允许单个函数签名，但我们可以编写自己的 overloaded_function_ref：

template <typename Derived, typename Sig>
class function_ref_impl;

template <typename Derived, typename R, typename... Args>
class function_ref_impl<Derived, R(Args...)> {
    using fn_t = R(*)(void const*, Args...);

public:
    auto operator()(Args... args) const -> R {
        return fn(static_cast<Derived const&>(*this).object, std::forward<Args>(args)...);
    }

protected:
    template <typename F,
        std::enable_if_t<!std::is_base_of<function_ref_impl, F>::value, int> = 0>
    explicit function_ref_impl(F const& f)
        : fn{[](void const* self, Args... args) -> R {
            return (*static_cast<F const*>(self))(std::forward<Args>(args)...);
        }}
    {}

private:
    fn_t fn;
};

template <typename... Sig>
class overloaded_function_ref
    : public function_ref_impl<overloaded_function_ref<Sig...>, Sig>...
{
public:
    template <typename F,
        std::enable_if_t<!std::is_base_of<overloaded_function_ref, F>::value, int> = 0>
    overloaded_function_ref(F const& f)
        : function_ref_impl<overloaded_function_ref, Sig>(f)...
        , object{std::addressof(f)}
    {}

    // Can be done pre-C++17, but it's not easy:
    using function_ref_impl<overloaded_function_ref, Sig>::operator()...;

    // This can be encapsulated with techniques such as the "passkey" idiom.
    // Variadic friend expansion isn't a thing (`friend bases...`).
    void const* object;
};

Live example

对于using /* base */::operator()...，确实需要 C++17，但可以在 C++14 中模拟；请参阅介绍此功能的论文：[P0195]，或者也许可以通过按摩 Boost HOF's match 来做到这一点。这也只是一个函数引用，而不是一个拥有函数。

那么我们可以这样写：

struct Processor {
    template <typename T>
    void process(T&& value) {
        cout << "some processing... ";
        emit(std::forward<T>(value));
    }

    using emitter_t = overloaded_function_ref<
        void(int),
        void(double),
        void(char*),
        void(char const*)
    >;

    emitter_t emit;
};

Demo

Answer 2

恕我直言：继承就是为了这个。

#include <iostream>
#include <utility>

using namespace std;

struct BaseEmitter {
    virtual void e(int) =0;
    virtual void e(double)=0;
    virtual void e(char*)=0;
    virtual void e(const char*)=0;
};

struct Emitter :public BaseEmitter {
    virtual void e(int) { cout << "emitting int\n";}
    virtual void e(double) { cout << "emitting double\n";}
    virtual void e(char*) { cout << "emitting char*\n";}
    virtual void e(const char*) { cout << "emitting const char*\n";}
};

struct Processor {
    BaseEmitter& e_;
    Processor(BaseEmitter& e) : e_(e) {}

    template <typename T>
    void process(T&& value) {
        cout << "some processing... ";
        e_(std::forward<T>(value));
    }
};


int main() {
    Emitter em;
    auto p = Processor(em);
    p.process(1);
    p.process("lol");
    return 0;
}

您可以通过接口中的继承来进行混合以捕获 lambda：

struct bypass
{
        virtual void operator()() = 0;
};

template<typename callable> struct capture: public bypass
{
        callable& _ref;
        capture(callable &ref)
        : _ref(ref)
        {;};

        virtual void operator()()
        {
                _ref();
        }
};

struct test
{
        bypass *_c;
        template<class T> test(T& callback)
        : _c(nullptr)
        {
          _c = new capture<decltype(callback)>(callback);
        };
        virtual ~test()
        {
            delete _c;
        };
        void doit()
        {
            (*_c)();
        }

};



int main(int argc, char* argv[])
{
        auto lambda = [](){std::cout << "hello\n";};
        test z=test(lambda);
        z.doit();
        return 0;
}

Answer 3

如果你愿意付出高昂的运行时成本来换取最小的限制，你可以使用std::function和std::any（对于C++14，使用boost::any）：

#include <iostream>
#include <utility>
#include <any>
#include <functional>

struct Processor {
    Processor(std::function<void(std::any)> e) : e_{e} {}

    template <typename T>
    void process(T&& value) {
        std::cout << "some processing... ";
        e_(std::forward<T>(value));
    }

    std::function<void(std::any)> e_;
};

struct Emitter {
    void e(int) { std::cout << "emitting int\n";}
    void e(double) { std::cout << "emitting double\n";}
    void e(char*) { std::cout << "emitting char*\n";}
    void e(const char*) { std::cout << "emitting const char*\n";}
};

int main() {
    Emitter em;
    auto p = Processor(
        [&em](std::any any){
            // This if-else chain isn't that cheap, but it's about the best
            // we can do. Alternatives include:
            // - Hashmap from `std::type_index` (possibly using a perfect hash)
            //   to a function pointer that implements this.
            // - Custom `any` implementation which allows "visitation":
            //
            //   any.visit<int, double, char*, char const*>([&em] (auto it) {
            //        em.e(it);
            //   });
            if (auto* i = std::any_cast<int>(&any)) {
                em.e(*i);
            } else if (auto* d = std::any_cast<double>(&any)) {
                em.e(*d);
            } else if (auto* cstr = std::any_cast<char*>(&any)) {
                em.e(*cstr);
            } else {
                em.e(std::any_cast<char const*>(any));
            }
        }
    );


    p.process(1);
    p.process("lol");
    return 0;
}

std::any 和 std::function 都拥有类型擦除包装器。您可能为此进行了堆分配，或者您可能适合他们的小对象优化。您将有虚函数调用（或等效函数）。

Compiler Explorer link

Answer 4

是否可以将通用 lambda 作为非模板参数传递

不能声明接受 lambda 作为参数的非模板函数。 lambda 的类型是匿名的：它没有名字。无法编写接受匿名类型参数的函数声明。

lambda 的类型可以推导，这就是为什么可以将 lambdas 传递到参数类型被推导的函数模板中。

虽然这回答了问题，但它并没有提供解决方案。我认为解决方案不会很简单。