减少样板时的装饰方法

Reducing boilerplate when decorating methods

本文关键字：方法      更新时间：2023-10-16

我有大量的类用来修饰一些特定的方法。

是否有一种干净的方法来减少需要添加到每个类中的样板代码(主要是所有构造函数参数和保存它们的成员)的数量?或者，更好的是，有更好的方法来做这件事吗?

我不能使用虚方法，只能使用gcc 4.6和vs2010支持的c++11特性子集。

我相信c++11继承构造函数在这里会有帮助，但是两个编译器都不支持它们，我也不知道有什么解决办法。

下面是这些类当前的样子的一个例子:

template<class Underlying, class T1>
struct A : Base<A<Underlying, T1> >
{
    typedef AImpl<decltype(declval<Underlying>().foo()), T1> impl;
    A(Underlying u, T1 t1) :
        u_(u),
        t1_(t1)
    {}
    impl foo() const { return impl(u_.foo(), t1_); }
    impl bar() const { return impl(u_.bar(), t1_); }
    const Underlying u_;
    T1 t1_;
};

template<class Underlying, class T1, class T2>
struct B : Base<B<Underlying, T1, T2> >
{
    typedef BImpl<decltype(declval<Underlying>().bar()), T1, T2> impl;
    B(Underlying u, T1 t1, T2 t2) :
        u_(u),
        t1_(t1),
        t2_(t2)
    {}
    impl foo() const { return impl(u_.bar(), 999, t2_); }
    impl bar() const { return impl(u_.foo(), t1_, t2_); }
    const Underlying u_;
    T1 t1_;
    T2 t2;
};

你可以在GCC 4.6中使用可变模板。

template<class Underlying, class... T>
struct B : Base<B<Underlying, T...>>
{
    typedef BImpl<decltype(declval<Underlying>().bar()), T...> impl;
    template<typename V...>
    B(Underlying u, V... v) :
        u_(u),
        t_(std::forward<V>(v)...)
    {}
    impl foo() const { return impl(u_.bar(), 999, std::get<1>(t_)); } // Not sure what the 999 is?
    impl bar() const { return impl(u_.foo(), std::get<0>(t_), std::get<1>(t_)); }
    const Underlying u_;
    std::tuple<T...> t_;
};

如果它需要在vs2010中工作，那么你最好的选择是Boost.Preprocessor。它不像可变模板那样健壮，因为它的最大递归深度为3，最大迭代计数为256，但它在每个编译器中都可以工作，无论是否支持c++ 11。我并不完全清楚你想用这些例子做什么，但如果你只是想修饰函数，我使用下面的代码(利用c++ 11与Boost完美转发)。预处理器而不是可变模板):

#define FORWARD(z, n, data) 
    ::std::forward<BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n)> 
    (BOOST_PP_CAT(BOST_PP_TUPLE_ELEM(2, 1, data), n)) 
    /**/
//------------------------------------------------------------------------
// template<class R, class... A>
// ::std::function<R(A...)> decorate(::std::function<R(A...)> const& func)
// {
//     return [func](A&&... a) -> R
//     {
//         /* DECORATOR STUFF */
//         return func(::std::forward<A>(a)...);
//     };
// }
//------------------------------------------------------------------------
#define MACRO(z, n, _) 
    template<class R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, class A)> 
    ::std::function<R(BOOST_PP_ENUM_PARAMS_Z(z, n, a)> 
        decorate(::std::function<R(BOOST_PP_ENUM_PARAMS_Z(z, n, A))> const& func) 
    { 
        return [func](BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, &&a)) -> R 
        { 
            /* DECORATOR STUFF */ 
            return func(BOOST_PP_ENUM_ ## z(n, FORWARD, (A, a))); 
        }; 
    } 
    /**/
BOOST_PP_REPEAT(10, MACRO, ~)
#undef MACRO
#undef FORWARD

如果你只是想绑定函数的参数，那么std::bind就是你要找的。请注意，您可以仅使用lambda来完成这些操作，但是decorator函数可以用于修饰多个函数(lambda当然是其中的一个)，并且bind对于绑定参数来说可以更简洁一些(然而，lambda等效函数有时更具可读性)。

相关文章：