Wie boost :: mpl :: vector in einen anderen boost :: mpl :: vector?

Question

Angenommen, ich habe eine boost::mpl::vector „myvec“, wie dies beispielsweise definiert:

using myvec = boost::mpl::vector<int, double, double>; 

Jetzt möchte ich einen anderen Typ, myvecex definieren, die jedes myvec Mitglied in std::tuple mit zusätzlichen String umwandelt. Ich möchte eine Art wie folgt definiert bekommen:

using myvecex = boost::mpl::vector<std::tuple<int, std::string>, 
            std::tuple<double, std::string>, 
            std::tuple<double, std::string> >; 

Aber ich will nicht wiederholen mich und Namen alle Vektorelemente. Stattdessen möchte ich some_smart_template Schablonentyp definieren, wo ich irgendwie die Logik der Umwandlung jedes Elementtyps in ein Tupel setzen werde.

using myvecex2 = some_smart_template<myvec>; 
static_assert(std::is_same<myvecex, myvecex2>::value); 

Ist es in C++ überhaupt machbar?

Answer 1

Boost.MPL gibt Ihnen nicht nur Container, sondern auch Algorithmen über diese Container. In diesem Fall, was Sie wollen, ist transform:

template< 
     typename Sequence 
    , typename Op 
    , typename In = unspecified 
    > 
struct transform 
{ 
    typedef unspecified type; 
}; 

Die Semantik sind Sie es eine Sequenz geben und welche MPL bezeichnet als Lambda Expression und Sie eine andere Sequenz raus. Im Einzelnen:

using B = mpl::transform<A, 
    std::tuple<mpl::_1, std::string> 
    >::type; 

Oder zumindest die funktionieren würde, wenn apply variadische Klasse Vorlagen wie std::tuple unterstützt. So müssen Sie nur eine Operation schreiben, ist entweder ein metafunction Klasse:

struct tuple_of_strings { 
    template <class T> 
    struct apply { 
     using type = std::tuple<T, std::string>; 
    }; 
}; 

using B = mpl::transform<A, tuple_of_strings>::type; 

oder ein metafunction:

template <class T> 
struct tuple_of_strings { 
    using type = std::tuple<T, std::string>; 
}; 

using B = mpl::transform<A, tuple_of_strings<_1>>::type;