Python 有一个非常有用的特性 function decorators ，此外，它允许组合。例如，如果编写一个函数foo，那么您可以声明您希望foo 为memoized。 , 还有 retried在 foo 也引发异常的缓存未命中情况下不止一次，方法是:

@lru_cache
@retry
def foo(...):

装饰器的可组合性允许独立开发像 foo 这样的函数和单独的函数装饰器，然后根据需要混合它们。如果我们也能在 C++ 中这样做(在可能的范围内)，那就太好了。

虽然 StackOverflow 上有几个关于函数装饰器的问题，但由于对装饰函数签名的严格假设，它们似乎都生成了不可组合的装饰器。例如，考虑对 this question 的优秀最高投票答案.装饰形式

template <typename R, typename... Args>
std::function<R (Args...)> memo(R (*fn)(Args...)) {

因此，它 cannot be applied to the result of itself (不可否认，对于特定的装饰器使用内存来说，这不是什么大问题)。

那么我们如何编写可组合的函数装饰器呢？

最佳答案

另一种创建可组合函数装饰器的方法是使用一组mixin类。
它遵循一个最小的工作示例:

#include<iostream>
#include<functional>
#include<utility>
#include<type_traits>

template<class T>
struct LoggerDecoratorA: public T {
    template<class U>
    LoggerDecoratorA(const U &u): T{u} { }

    template<typename... Args>
    auto operator()(Args&&... args) const ->
        typename std::enable_if<
            not std::is_same<
                typename std::result_of<T(Args...)>::type,
                void
            >::value,
        typename std::result_of<T(Args...)>::type>::type
    {
        using namespace std;
        cout << "> logger A" << endl;
        auto ret = T::operator()(std::forward<Args>(args)...);
        cout << "< logger A" << endl;
        return ret;
    }

    template<typename... Args>
    auto operator()(Args&&... args) const ->
        typename std::enable_if<
            std::is_same<
                typename std::result_of<T(Args...)>::type,
                void
            >::value,
        typename std::result_of<T(Args...)>::type>::type
    {
        using namespace std;
        cout << "> logger A" << endl;
        T::operator()(std::forward<Args>(args)...);
        cout << "< logger A" << endl;
    }
};

template<class T>
struct LoggerDecoratorB: public T {
    template<class U>
    LoggerDecoratorB(const U &u): T{u} { }

    template<typename... Args>
    auto operator()(Args&&... args) const ->
        typename std::enable_if<
            not std::is_same<
                typename std::result_of<T(Args...)>::type,
                void
            >::value,
        typename std::result_of<T(Args...)>::type>::type
    {
        using namespace std;
        cout << "> logger B" << endl;
        auto ret = T::operator()(std::forward<Args>(args)...);
        cout << "< logger B" << endl;
        return ret;
    }

    template<typename... Args>
    auto operator()(Args&&... args) const ->
        typename std::enable_if<
            std::is_same<
                typename std::result_of<T(Args...)>::type,
                void
            >::value,
        typename std::result_of<T(Args...)>::type>::type
    {
        using namespace std;
        cout << "> logger B" << endl;
        T::operator()(std::forward<Args>(args)...);
        cout << "< logger B" << endl;
    }
};

int main() {
    std::function<int()> fn = [](){
        using namespace std;
        cout << 42 << endl;
        return 42;
    };

    std::function<void()> vFn = [](){
        using namespace std;
        cout << "void" << endl;
    };

    using namespace std;

    decltype(fn) aFn =
        LoggerDecoratorA<decltype(fn)>(fn);
    aFn();

    cout << "---" << endl;

    decltype(vFn) bVFn =
        LoggerDecoratorB<decltype(vFn)>(vFn);
    bVFn();

    cout << "---" << endl;

    decltype(fn) abFn =
        LoggerDecoratorA<LoggerDecoratorB<decltype(fn)>>(fn);
    abFn();

    cout << "---" << endl;

    decltype(fn) baFn =
        LoggerDecoratorB<LoggerDecoratorA<decltype(fn)>>(fn);
    baFn();
}

我不确定您提到的问题实际上解决了哪些问题，但请随时要求更改，如果可能，我会尝试更新它。

关于c++ - 可组合的 C++ 函数装饰器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36206515/