Сокращение шаблонов при декорировании

Question

У меня есть большое количество классов, которые используются для украшения нескольких конкретных методов.

Есть ли чистый способ уменьшить объем стандартного кода (в основном всех параметров конструктора и членов для их хранения), который необходимо добавить в каждый из этих классов? Или, еще лучше, есть лучший способ сделать это?

Я не могу использовать виртуальные методы и могу использовать только подмножество функций c ++ 11, поддерживаемых gcc 4.6 и vs2010.

Я полагаю, что здесь помогут конструкторы, наследующие 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;
};

Answer 1

Если он должен работать в vs2010, тогда ваша лучшая ставка - Boost.Preprocessor . Он не так надежен, как шаблоны с вариадностью, поскольку он имеет максимальную глубину рекурсии 3 и максимальное число итераций 256, но он работает в каждом компиляторе с поддержкой C ++ 11 или без нее. Не совсем понятно, что вы пытаетесь сделать с этими примерами, но если вы просто пытаетесь декорировать функции, я использую следующее (использует C ++ 11 для идеальной пересылки с Boost.Preprocessor вместо шаблонов с переменным числом аргументов):

#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 - это то, что вы ищете. Обратите внимание, что вы можете сделать все это только с помощью lambdas , но функции декоратора можно использовать для декорирования нескольких функций (где лямбды, конечно, однозначно), а связывание может быть немного более кратким для аргументов привязки (однако лямбда-эквивалент иногда более читабелен).

Answer 2

В 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_;
};