Индексирование с использованием шаблонов с переменными параметрами - PullRequest
Новая
       20

Индексирование с использованием шаблонов с переменными параметрами

2 голосов
/ 25 апреля 2011

Допустим, у меня есть пакет параметров, который я развертываю, например, 

template<typename... P> void f(P...&& args) {
    some_other_func(std::forward<P>(args)...);
}

Теперь предположим, что у меня есть какая-то другая второстепенная функция, через которую эти объекты должны пройти. 

template<typename T> T&& some_func(T&& ref) {
    // replace with actual logic
    return std::forward<T>(ref);
}

Обычно я просто заменяю на 

template<typename... P> void f(P...&& args) {
    some_other_func(some_func(args)...);
}

Но что мне делать, если some_func требует больше информации о параметре, чем просто о его типе, как, например, его числовое положение в пакете параметров?Так что вместо расширения до 

some_other_func(some_func(arg1), some_func(arg2));

я мог бы развернуть его до 

some_other_func(some_func(arg1, 1), some_func(arg2, 2));

, например?

Ответы [ 2 ]

2 голосов
/ 26 апреля 2011

Я знаю, что решил это раньше, но не могу вспомнить, как.О, хорошо, вот свежий взгляд.

Последовательность чисел может быть переведена в последовательность аргументов с помощью std::get, поэтому она более фундаментальная.Итак, если предположить, что мне нужно реализовать какой-то специальный инструмент, генератор пакетов с номерами кажется хорошим выбором.

(Гм, это было невероятно утомительно. Я заглянул в ответ Говарда и узнал о forward_as_tuple, но эта функция еще даже не существует на моем компиляторе или ideone.com, так что, черт возьми. Мне еще многое нужно понять, и это, безусловно, один из худших функциональных языков, когда-либо изобретенных.)

http://ideone.com/u5noV

#include <tuple>

// Generic pack array (metacontainer)
template< typename T, T ... seq > struct value_sequence {
    // Append a value to the array (metafunction)
    template< T val > struct append
        { typedef value_sequence< T, seq..., val > type; };
};

// Generate a sequential array (metafunction)
template< size_t N >
struct index_sequence {
    typedef typename index_sequence< N - 1 >::type
                      ::template append< N - 1 >::type type;
};

template<>
struct index_sequence< 0 >
    { typedef value_sequence< size_t > type; };

// Generate indexes up to size of given tuple (metafunction)
template< typename T >
struct index_tuple {
    typedef typename index_sequence< std::tuple_size< T >::value
                                   >::type type;
};

// The magic function: passes indexes, makes all the function calls
template< typename F, typename G,
          typename T, size_t ... N >
void compose_with_indexes_helper( F f, G g, T args,
        value_sequence< size_t, N ... > ) {
    f( g( std::get< N >( args ), N ) ... );
}

template< typename F, typename G, typename ... T >
void compose_with_indexes( F f, G g, T && ... args ) {
    typedef std::tuple< T && ... > tuple_t;
    compose_with_indexes_helper
//        forwarding seems broken on ideone.com/GCC 4.5.1, work around.
//        ( f, g, std::forward_as_tuple( std::forward( args ) ... ) );
        ( f, g, tuple_t( args ... ), typename index_tuple< tuple_t >::type() );
}
2 голосов
/ 25 апреля 2011

Это немного запутанно.Но вот рабочий прототип вашего кода с использованием нескольких частных утилит libc ++ , найденных в <__ tuple> и . 

#include <iostream>
#include <tuple>

template<typename T>
int
some_func(T&& ref, size_t I)
{
    std::cout << "ref = " << ref << ", I = " << I << '\n';
    return 0;
}

template<typename... T, size_t ...Indx>
void
some_other_func(std::tuple<T...> ref, std::__tuple_indices<Indx...>) {
    // replace with actual logic
    std::__swallow(some_func(std::get<Indx>(ref), Indx)...);
}


template<typename... P>
void
f(P&&... args)
{
    some_other_func(std::forward_as_tuple<P...>(std::forward<P>(args)...),
                    typename std::__make_tuple_indices<sizeof...(P)>::type());
}

int main()
{
    f("zero", "one", "two", "three");
}

ref = zero, I = 0
ref = one, I = 1
ref = two, I = 2
ref = three, I = 3
...