#include <string>
#include <iostream>

enum _n_Height  { n_Height };
enum _n_Weight  { n_Weight };
enum _n_Name    { n_Name };

struct Fake_Struct { void operator []( Fake_Struct const& ); };

template < class _Tx, class _Name, class _Super = Fake_Struct >
  struct Struct : _Super
    {
      using _Super::operator[];

      _Tx val_;
      _Tx& operator []( _Name n ) { return val_; }

      Struct() : val_(_Tx()) {}
    };

typedef 
  Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
  MyStruct;


int main()
  {

    MyStruct s;

    s[n_Height]  = 10;
    s[n_Weight]  = 20.3;
    s[n_Name]    = "name";

    std::cout
      << s[n_Height]  << std::endl
      << s[n_Weight]  << std::endl
      << s[n_Name]    << std::endl
      ;

    return 0;

  }

>
> #include <string>
> #include <iostream>
>
> enum _n_Height  { n_Height };
> enum _n_Weight  { n_Weight };
> enum _n_Name    { n_Name };
>
> struct Fake_Struct { void operator []( Fake_Struct const& ); };
>
> template < class _Tx, class _Name, class _Super = Fake_Struct >
>   struct Struct : _Super
>     {
>       using _Super::operator[];
>
>       _Tx val_;
>       _Tx& operator []( _Name n ) { return val_; }
>
>       Struct() : val_(_Tx()) {}
>     };
>
> typedef
>   Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
>   MyStruct;
>
>
> int main()
>   {
>
>     MyStruct s;
>
>     s[n_Height]  = 10;
>     s[n_Weight]  = 20.3;
>     s[n_Name]    = "name";
>
>     std::cout
>       << s[n_Height]  << std::endl
>       << s[n_Weight]  << std::endl
>       << s[n_Name]    << std::endl
>       ;
>
>     return 0;
>
>   }
>

> Выкриков — 'баян' и тухлых помидоров я не боюсь, ибо действительно прикольно.

1. Сам факт, что до объявления кортежа нужно объявить имена его членов, а при объявлении объявить имена и их типы убивают всю идею на корню. Я не вижу, чем приведенный выше кортеж лучше, чем обычное
   

   struct my_struct
   {
        int height;
        float weight;
        std::string name;
   };

   
   Я вижу лишь что на описание этой же структуры в оригинальном коде ушло больше писанины без какой либо пользы.
   
2. Практическая применимость такого кортежа в шаблонном коде близка к абсолютному нулю. Ничего не стоит в compile time определить количество членов boost::tuple и проитерироваться по его членам, так как индексом его членов является целое, результаты арифметических операций над которым вычисляются в compile time. По приведенному кортежу невозможно проитерироваться в generic коде, так как нужно знать имена членов. Возвращемся к тому, что индексы должны быть простыми целыми.
   С другой стороны целочисленные индексы не убивают возможности использовать осмысленные имена. boost::tuple:
   

   typedef tuple<int, float, std::string> my_struct;
   enum { height, weight, name };
   // ...
   my_struct s;
   get<height>(s) = 1;

   
   Я не вижу недостатка в том, что вместо operator[] для доступа к членам используется get<>(), так как реально никакого практического смыла в operator[] нет из-за того, что он не может использоваться в generic коде который ожидает семантику operator[] как у встроенных типов.

int main()
  {
    Scord< _sf_iHeight, Scord<_sf_fWeight, Scord<_sf_szName> > > s;

    sf_iHeight[s] = 10;
    sf_fWeight[s] = 20.3;
    sf_szName[s] = "jony";

    std::cout
      << sf_iHeight[s]  << std::endl
      << sf_fWeight[s]  << std::endl
      << sf_szName[s]   << std::endl
      << std::endl
      ;
 
    return 0;
  }

#define TEGGO_SFIELD(name,type) \
  struct _sf_##name : Sfield< type, _sf_##name > {}; \
  /*static*/ _sf_##name const sf_##name = _sf_##name()

template < class _Key >
  struct _Scord_Value
    {
      typename _Key::_Type sf_value_;
      _Scord_Value() : sf_value_(typename _Key::_Type()) {}
    };

template < class _Tp, class _Self >
  struct Sfield
    {
      typedef _Tp _Type;
      template < class _Value >
        _Type& operator[](_Value &val) const
        {
          return static_cast<_Scord_Value<_Self>&>(val).sf_value_;
        };
    };

struct _Scord_Fake {};

template < class _Key, class _Lst = _Scord_Fake >
  struct Scord : _Scord_Value<_Key>, _Lst 
    {
    };

TEGGO_SFIELD(iHeight, int);
TEGGO_SFIELD(fWeight, float);
TEGGO_SFIELD(szName,  std::string);

enum stop_t  { cmd_stop = 0x1001 };
enum start_t { cmd_start = 0x2000 };
enum pause_t { cmd_pause = 0x40000 };

get<N>(t)

where t is a tuple object and N is a constant integral expression specifying the index of the element to be accessed. Depending on whether t is const or not, get returns the Nth element as a reference to const or non-const type. The index of the first element is 0 and thus N must be between 0 and k-1, where k is the number of elements in the tuple. Violations of these constrains are detected at compile time.

Каждый желающий запостить идею или пример кода должен приложить подробно разжёванное описание (понятное для кофейников), а так же примеры на которых доступно показано чем его идея лучше чем boost. Примеры должны быть написаны в терминах буста с использованием буста и на задачах решаемых бустом. Отсутствие буста в примерах и идее, а так же непонимание почитателями буста, почему таковое кому либо может быть интересно, карается всеобщем порицанием и удалением.

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/unique.hpp>
#include <boost/mpl/size.hpp>
#include <Boost/mpl/at.hpp>
#include <boost/type_traits/is_same.hpp>
#include <string>
#include <iostream>

#ifndef FAKIE_TAGGED_TUPLE_MAX_ARITY
# define FAKIE_TAGGED_TUPLE_MAX_ARITY 10
#elif FAKIE_TAGGED_TUPLE_MAX_ARITY > 10
#error boost::tuples doesn't support arity > 10
#endif

namespace fakie
{
    template<typename Types, typename Names, typename Base>
    struct tagged_tuple_detail 
        : virtual Base
        , boost::enable_if_c<boost::mpl::size<Types>::type::value == boost::mpl::size<Names>::type::value>
        , boost::enable_if<boost::is_same<boost::mpl::unique<Types>, Types> >
    {
        using Base::get;

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::non_const_type get ()
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::const_type get () const
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }
    };

#define FAKIE_TAGGED_TUPLE_DETAIL_TYPES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))

#define FAKIE_TAGGED_TUPLE_DETAIL_VALUES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_ADD(BOOST_PP_MUL(2, n), 1))

#define FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE(z, n, text)\
    BOOST_PP_COMMA_IF(n)\
    typename boost::mpl::if_<\
        boost::is_same<BOOST_PP_CAT(text, BOOST_PP_MUL(2, n)), boost::mpl::na>,\
        boost::tuples::null_type,\
        BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))\
    >::type

    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_MUL(2, FAKIE_TAGGED_TUPLE_MAX_ARITY), typename T, boost::mpl::na)>
    struct tagged_tuple
        : tagged_tuple_detail
        <
            boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_TYPES, T)>,
            boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_VALUES, T)>,
            boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>
        >
    {
    };

#undef FAKIE_TAGGED_TUPLE_DETAIL_TYPES
#undef FAKIE_TAGGED_TUPLE_DETAIL_VALUES
#undef FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE
}

class name_t {};
class value_t {};
class weight_t {};

int main()
{
    using namespace fakie;

    tagged_tuple<std::string, name_t, int, value_t, double, weight_t> s;
    
    s.get<name_t>()   = "Hello World";
    s.get<value_t>()  = 2005;
    s.get<weight_t>() = 2.34543;

    std::cout << s;

    return k;
}

typedef tuple<int, float, std::string> my_struct;
enum { height, weight, name };
// ...
my_struct s;
get<height>(s) = 1;

class name_t   {};
class number_t {};
tagged_tuple<std::string, name_t, int, number_t> s;
s.get<name_t>() = "hello world";
s.get<number_t>() = 2005;
assert(s.get<0>() == s.get<name_t>());
assert(s.get<1>() == s.get<number_t>());

boost::tuple<std::string, int> s;
cin  >> s;
cout << s;

PC>Показываю Copyright мой. Не отвечаю за последствия от увиденного. Нервных прошу воздержаться от просмотра Работает на VC7.1 и VC8

std::cout << sizeof(int) << std::endl;
std::cout << sizeof(double) << std::endl;
std::cout << sizeof(tagged_tuple<int, value_t, double, weight_t>) << std::endl;

AC>Хороший показательный пример программирования на BOOST++. Звиняй, но я пишу на С++, потому в моём коде ты таких диких конструкций не увидишь.

typedef 
  Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
  MyStruct;

AC>std::cout << sizeof(tagged_tuple<int, value_t, double, weight_t>) << std::endl;
AC>

void
submit_deliver_base_t::write_to(
    pdu_t & to,
    command_header_t::integer_t sequence_number ) const
{
    // Промежуточный буфер, в который помещается
    // временное двоичное значение.
    oess_1::io::mem_buf_t buf;

    // Записываем обязательные параметры.
    buf << m_service_type
        << m_source_addr_ton
        << m_source_addr_npi
        << m_source_addr
        << m_dest_addr_ton
        << m_dest_addr_npi
        << m_dest_addr
        << m_esm_class
        << m_protocol_id
        << m_priority_flag
        << m_schedule_delivery_time
        << m_validity_period
        << m_registered_delivery
        << m_replace_if_present_flag
        << m_data_coding
        << m_sm_default_msg_id
        << m_short_message
    // Записываем необязательные параметры.
        << opt_params();

    // Формируем PDU.
    to.set( m_command_id,
        // command_status должен быть 0.
        0,
        sequence_number,
        buf.size(),
        reinterpret_cast< const pdu_t::octet_t * >( buf.ptr() ) );
}

AC>Хум-хоу Только не забудь про тормаза на хипе. В моём случае это был многопоточный сервер на мнгопроцессорной машине.

E>>    buf << m_service_type
E>>    // Формируем PDU.
E>>

class    SMPP_PDU_1_TYPE    c_string_t
:    public std::string
,    public smpp_serializable_t
{
...
};

//! Извлечение объекта из потока.
inline oess_1::io::istream_t &
operator>>( oess_1::io::istream_t & from, c_string_t & o )
{
    o.read_from( from );
    return from;
}

//! Помещение объекта в поток.
inline oess_1::io::ostream_t &
operator<<( oess_1::io::ostream_t & to,
    const c_string_t & o )
{
    o.write_to( to );
    return to;
}

template< class Length_type >
class    octet_string_t
:    public std::string
,    public smpp_serializable_t
{
...
};

//! Извлечение объекта из потока.
template< class Length_type >
inline oess_1::io::istream_t &
operator>>( oess_1::io::istream_t & from,
    octet_string_t< Length_type > & o )
{
    o.read_from( from );
    return from;
}

//! Помещение объекта в поток.
template< class Length_type >
inline oess_1::io::ostream_t &
operator<<( oess_1::io::ostream_t & to,
    const octet_string_t< Length_type > & o )
{
    o.write_to( to );
    return to;
}

PC>Я знаю, оверхэд из-за виртуального наследования... щас добавлю пять строк на все конструкторы и никакого оверхэда совсем. Зато пользователь радуется, в отличие от твоего

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repeat_from_to.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/unique.hpp>
#include <boost/mpl/size.hpp>
#include <Boost/mpl/at.hpp>
#include <boost/type_traits/is_same.hpp>
#include <string>
#include <iostream>

#ifndef FAKIE_TAGGED_TUPLE_MAX_ARITY
# define FAKIE_TAGGED_TUPLE_MAX_ARITY 10
#elif FAKIE_TAGGED_TUPLE_MAX_ARITY > 10
#error boost::tuples doesn't support arity > 10
#endif

namespace fakie
{

#define FAKIE_TAGGED_TUPLE_DETAIL_TYPES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))

#define FAKIE_TAGGED_TUPLE_DETAIL_VALUES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_ADD(BOOST_PP_MUL(2, n), 1))

#define FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE(z, n, text)\
    BOOST_PP_COMMA_IF(n)\
    typename boost::mpl::if_<\
        boost::is_same<BOOST_PP_CAT(text, BOOST_PP_MUL(2, n)), boost::mpl::na>,\
        boost::tuples::null_type,\
        BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))\
    >::type

    template<typename Types, typename Names>
    struct detail_check_types_and_names
        : boost::enable_if_c<boost::mpl::size<Types>::type::value == boost::mpl::size<Names>::type::value>
        , boost::enable_if<boost::is_same<typename boost::mpl::unique<Types>::type, Types> >
    {
    };

    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_MUL(2, FAKIE_TAGGED_TUPLE_MAX_ARITY), typename T, boost::mpl::na)>
    struct tagged_tuple
        : boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>
    {
        typedef boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_TYPES, T)>  Types;
        typedef boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_VALUES, T)> Names;
        typedef boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>  Base;

#define FAKIE_TAGGED_TUPLE_DETAIL_CTORS(z, n, text)\
        template<BOOST_PP_ENUM_PARAMS(n, typename U)>\
        tagged_tuple(BOOST_PP_ENUM_BINARY_PARAMS(n, U, & u), detail_check_types_and_names<Types, Names> * = 0)\
            : Base(BOOST_PP_ENUM_PARAMS(n, u)) {}

        tagged_tuple(detail_check_types_and_names<Types, Names> * = 0) {}

        BOOST_PP_REPEAT_FROM_TO(1, FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_CTORS, _)

#undef  FAKIE_TAGGED_TUPLE_DETAIL_CTORS

        using Base::get;

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::non_const_type get ()
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::const_type get () const
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }
    };

#undef FAKIE_TAGGED_TUPLE_DETAIL_TYPES
#undef FAKIE_TAGGED_TUPLE_DETAIL_VALUES
#undef FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE
}

class name_t {};
class value_t {};
class weight_t {};

int main()
{
    using namespace fakie;

    tagged_tuple<std::string, name_t, int, value_t> s;
    
    s.get<name_t>()   = "Hello World";
    s.get<value_t>()  = 2005;

    std::cout << s << ' '
              << sizeof(s) << ' '
              << sizeof(boost::tuple<std::string, int>) << ' '
              << sizeof(std::string) + sizeof(int);

    return 0;
}

class name_t {};
class value_t {};
class weight_t {};

void foo()
{
    tagged_tuple<std::string, name_t, int, value_t> s;
    
    s.get<name_t>()   = "Hello World";
    s.get<value_t>()  = 2005;
}

enum _n_Height  { n_Height };
enum _n_Weight  { n_Weight };
enum _n_Name    { n_Name };

struct Fake_Struct { void operator []( Fake_Struct const& ); };

template < class _Tx, class _Name, class _Super = Fake_Struct >
  struct Struct : _Super
    {
      using _Super::operator[];

      _Tx val_;
      _Tx& operator []( _Name n ) { return val_; }

      Struct() : val_(_Tx()) {}
    };

typedef 
  Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
  MyStruct;


int main()
  {

    MyStruct s;

    s[n_Height]  = 10;
    s[n_Weight]  = 20.3;
    s[n_Name]    = "name";

template < unsigned _No, class _Tx >
  struct valT 
    { typedef typename valT<_No-1,typename _Tx::_Next>::_Type _Type; };

template<class _Tx> 
  struct valT<0,_Tx> 
    { typedef _Tx _Type; };

template < unsigned _No, class _Tx >
  typename valT<_No,_Tx>::_Type::_Type& get(_Tx &x) 
    { 
      return static_cast<typename valT<_No,_Tx>::_Type&>(x).val_;
    }

...
template < class _Tx, class _Name, class _Super = Fake_Struct >
  struct Struct : _Super
    {
      typedef _Super _Next;
      typedef _Tx    _Type;
...

TEGGO_SFIELD(iHeight, int);

TEGGO_SFIELD(name, id, type, default);