Это введение. САБЖ будет в ответе.

Для начала что такое тупл:

Короче говоря это картэж разнотипных значений.
Обычно используют в качестве возвращаемого значения функций.

Описание:

#include "typelist.h"

// тупл
template <class Typelist>
struct    tuple;

template <class Head, class Tail>
struct    tuple< TL::typelist<Head, Tail> >
{
    Head        value;
    tuple<Tail>    next;
};

template <class Head>
struct    tuple< TL::typelist<Head, TL::null_type> >
{
    Head        value;
};

// пример использования
tuple<MAKE_TL(char, float, int)> fn_test()
{
  tuple<MAKE_TL(char, float, int)> tp= {'b', 5.5, 10};
  return tp;
}

файл "typelist.h"

// списки типов
namespace TL {

struct    null_type;

template <class Head, class Tail>
struct    typelist
{
    typedef Head head;
    typedef Tail tail;
};

// генерация списков типов
    //    make_typelist
template
<
    class Type01= null_type, class Type02= null_type,
    class Type03= null_type, class Type04= null_type,
    class Type05= null_type, class Type06= null_type,
    class Type07= null_type, class Type08= null_type,
    class Type09= null_type, class Type10= null_type,
    class Type11= null_type, class Type12= null_type,
    class Type13= null_type, class Type14= null_type,
    class Type15= null_type, class Type16= null_type,
    class Type17= null_type, class Type18= null_type,
    class Type19= null_type, class Type20= null_type
>
struct    make_typelist
{
private:
    typedef typename make_typelist
        <                    Type02, Type03, Type04, Type05, Type06, Type07, Type08, Type09,
            Type10, Type11,    Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19,
            Type20
        >::result tail_result;
public:
    typedef typelist<Type01, tail_result> result;
};

template <>
struct    make_typelist<>
{
    typedef null_type result;
};

#define MAKE_TL(...)    typename TL::make_typelist<__VA_ARGS__>::result

} // namespace

Здравствуйте, Sm0ke, Вы писали:

....

может быть boost.tuple ?

Итак ответ...

Идя такова, чтоб переопределить оператор += для: тупла справа и любого значения слева. Результатом оператора будет новый тупл.

#include "tuple.h"

#include <iostream>

int _tmain()
{
    std::cout
        << (1 += 5.5 += 'a' += "test" += end_tuple())
        << std::endl;
}

Результат выполнения:

1 : 5.5 : a : test

Файл "tuple.h"

#include "typelist.h"

template <class Typelist>
struct    tuple;

template <class Head, class Tail>
struct    tuple< TL::typelist<Head, Tail> >
{
    typedef TL::typelist<Head, Tail> path;

    Head        value;
    tuple<Tail>    next;

    template <class T>
    struct    added
    {
        typedef tuple< TL::typelist<T, path> > type;
    };

    template <class T>
    typename added<T>::type friend operator +=(T item, tuple tail_tp)
    {
        added<T>::type tp= {item, tail_tp};
        return tp;
    }

#ifdef _OSTREAM_
    friend std::ostream & operator <<(std::ostream & o, tuple tp)
    {
        return o << tp.value << " : " << tp.next;
    }
#endif
};

template <class Head>
struct    tuple< TL::typelist<Head, TL::null_type> >
{
    typedef TL::typelist<Head, TL::null_type> path;

    Head        value;

    template <class T>
    struct    added
    {
        typedef tuple< TL::typelist<T, path> > type;
    };

    template <class T>
    typename added<T>::type friend operator +=(T item, tuple tail_tp)
    {
        added<T>::type tp= {item, tail_tp};
        return tp;
    }

#ifdef _OSTREAM_
    friend std::ostream & operator <<(std::ostream & o, tuple tp)
    {
        return o << tp.value;
    }
#endif
};

struct    end_tuple
{
    template <class T>
    tuple< TL::typelist<T, TL::null_type> >
        friend operator +=(T item, end_tuple)
    {
        tuple< TL::typelist<T, TL::null_type> > tp= { item };
        return tp;
    }
};

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Sm0ke, Вы писали:

А>....

А>может быть boost.tuple ?

А как в бусте генерируются туплы?

У меня так: return 1 += 5.5 += 'b' += end_tuple;

Здравствуйте, Sm0ke, Вы писали:

S>Здравствуйте, Аноним, Вы писали:

А>>Здравствуйте, Sm0ke, Вы писали:

А>>....

А>>может быть boost.tuple ?

S>А как в бусте генерируются туплы?

S>У меня так: return 1 += 5.5 += 'b' += end_tuple;

примерно так :

return boost::make_tuple( 1, 5.5, 'b' );

Sm0ke пишет:
>
> У меня так: return 1 += 5.5 += 'b' += end_tuple;

Слишком много лишних выражений, затрудняющих чтение и восприятие кода по
сравнению c чем-то типа cr_tuple(1, 5.5, 'b')

Здравствуйте, Sm0ke, Вы писали:


S>Для начала что такое тупл:
S>Короче говоря это картэж разнотипных значений.
S>Обычно используют в качестве возвращаемого значения функций.

S>файл "typelist.h"

ИМО со списком типов нужно быть по осторожнее. Я было раз обжегся на этом когда VC7.1 падал с ошибкой IC на больших списках (~12 элементов). Самое обидное что на маленьких тестовых проектах все работает и проявляется только в большом проекте.

Здравствуйте, ArtDenis, Вы писали:

AD>Sm0ke пишет:
>>
>> У меня так: return 1 += 5.5 += 'b' += end_tuple;

AD>Слишком много лишних выражений, затрудняющих чтение и восприятие кода по
AD>сравнению c чем-то типа cr_tuple(1, 5.5, 'b')

если уж г-ну Sm0ke хочеца извратом тада мож так:

return begin_tuple, 1, 5.5, 'b', end_tuple;

Здравствуйте, AndrewJD, Вы писали:

AJD>ИМО со списком типов нужно быть по осторожнее.

список типов это никак не тупл, а какой-нить контейнер из mpl, например boost::mpl::vector.

Здравствуйте, Sni4ok, Вы писали:

AJD>>ИМО со списком типов нужно быть по осторожнее.
S>список типов это никак не тупл, а какой-нить контейнер из mpl, например boost::mpl::vector.

Я всегда думал что список типов более фундаментальное понятие чем контейнер из mpl.

Здравствуйте, AndrewJD, Вы писали:

AJD>Я всегда думал что список типов более фундаментальное понятие чем контейнер из mpl.

разумеется, например Loki::Typelist тоже является списком типов, но вот boost::tuple, или же std::pair списком типов не являются.

Здравствуйте, zaufi, Вы писали:

Z>Здравствуйте, ArtDenis, Вы писали:

AD>>Sm0ke пишет:
>>>
>>> У меня так: return 1 += 5.5 += 'b' += end_tuple;

AD>>Слишком много лишних выражений, затрудняющих чтение и восприятие кода по
AD>>сравнению c чем-то типа cr_tuple(1, 5.5, 'b')

Z>если уж г-ну Sm0ke хочеца извратом тада мож так:
Не очень. Такие вещи, как туплы должны быть в языке изначально ИМО.
Просто Ф-ция make_tuple() перегружена для ограниченного кол-ва аргументов.
Z>

Z>return begin_tuple, 1, 5.5, 'b', end_tuple;
Z>

Z>

Два вопроса:
1. Это есть в бусте?
2. Если нет, то как вы это реализуете?

Ведь оператор запятая вычисляется слева-направо. Слишком много копирований будет. memcpy() не предлагать =)
Вот оператор += вычисляется справа-налево.

Здравствуйте, AndrewJD, Вы писали:

AJD>Здравствуйте, Sm0ke, Вы писали:


S>>Для начала что такое тупл:
S>>Короче говоря это картэж разнотипных значений.
S>>Обычно используют в качестве возвращаемого значения функций.

S>>файл "typelist.h"

AJD>ИМО со списком типов нужно быть по осторожнее. Я было раз обжегся на этом когда VC7.1 падал с ошибкой IC на больших списках (~12 элементов). Самое обидное что на маленьких тестовых проектах все работает и проявляется только в большом проекте.

Попробую угадать
Вы наверное спомощью генератора иерархий делали обобщённый визитор?
GenLinearHierarchy<>::Result / GenScatterHierarchy<>::Result

Здравствуйте, Sni4ok, Вы писали:

S>Здравствуйте, AndrewJD, Вы писали:

AJD>>Я всегда думал что список типов более фундаментальное понятие чем контейнер из mpl.

S>разумеется, например Loki::Typelist тоже является списком типов, но вот boost::tuple, или же std::pair списком типов не являются.

В некоторых реализациях туплов используются списки типов.
В Loki точно используется. Насчёт boost::mpl не уверен...

з.ы. Моя пробная реализация туплов построена на списках.

Здравствуйте, Sm0ke, Вы писали:

AJD>>>Я всегда думал что список типов более фундаментальное понятие чем контейнер из mpl.

S>>разумеется, например Loki::Typelist тоже является списком типов, но вот boost::tuple, или же std::pair списком типов не являются.

S>В некоторых реализациях туплов используются списки типов.

ваша логика хромает, приведу пример, содержащий аналогичную логичную ошибку:
"boost::serialization использует boost::mpl, поэтому когда я использую boost::serialization, я занимаюсь метапрограммированием."

S>з.ы. Моя пробная реализация туплов построена на списках.

а я предпочитаю кататься на роликах.