Holen Sie Teil von std::tuple

Möglicherweise gibt es einen einfacheren Weg, aber das ist ein Anfang. Die "tail" - Funktion template gibt ein Tupel kopiert alle Werte des Originals mit Ausnahme des ersten. Dies kompiliert mit GCC 4.6.2 in C++0x-Modus.

template<size_t I>
struct assign {
  template<class ResultTuple, class SrcTuple>
  static void x(ResultTuple& t, const SrcTuple& tup) {
    std::get<I - 1>(t) = std::get<I>(tup);
    assign<I - 1>::x(t, tup);
  }
};

template<>
struct assign<1> {
  template<class ResultTuple, class SrcTuple>
  static void x(ResultTuple& t, const SrcTuple& tup) {
    std::get<0>(t) = std::get<1>(tup);
  }
};


template<class Tup> struct tail_helper;

template<class Head, class... Tail>
struct tail_helper<std::tuple<Head, Tail...>> {
  typedef typename std::tuple<Tail...> type;
  static type tail(const std::tuple<Head, Tail...>& tup) {
    type t;
    assign<std::tuple_size<type>::value>::x(t, tup);
    return t;
  }
};

template<class Tup>
typename tail_helper<Tup>::type tail(const Tup& tup) {
  return tail_helper<Tup>::tail(tup);
}

Machte ich einige änderungen an Adam ' s code, dass würde Streifen aus den ersten N Argumente der Tupel, sowie erstellen Sie ein neues Tupel mit nur die letzten N-Arten ... Hier ist der vollständige code (Hinweis: wenn jemand beschließt, +1 meine Antwort, bitte auch +1 Adams Antwort, da das ist, was dieser code basiert auf, und ich will nicht zu nehmen einen Kredit Weg von seinem Beitrag):

//create a struct that allows us to create a new tupe-type with the first
//N types truncated from the front

template<size_t N, typename Tuple_Type>
struct tuple_trunc {};

template<size_t N, typename Head, typename... Tail>
struct tuple_trunc<N, std::tuple<Head, Tail...>>
{
    typedef typename tuple_trunc<N-1, std::tuple<Tail...>>::type type;
};

template<typename Head, typename... Tail>
struct tuple_trunc<0, std::tuple<Head, Tail...>>
{
    typedef std::tuple<Head, Tail...> type;
};

/*-------Begin Adam's Code-----------

Note the code has been slightly modified ... I didn't see the need for the extra
variadic templates in the "assign" structure.  Hopefully this doesn't break something
I didn't forsee

*/

template<size_t N, size_t I>
struct assign 
{
    template<class ResultTuple, class SrcTuple>
    static void x(ResultTuple& t, const SrcTuple& tup) 
    {
        std::get<I - N>(t) = std::get<I>(tup);  
        assign<N, I - 1>::x(t, tup);  //this offsets the assignment index by N
    }
};

template<size_t N>
struct assign<N, 1> 
{
    template<class ResultTuple, class SrcTuple>
    static void x(ResultTuple& t, const SrcTuple& tup) 
    {
        std::get<0>(t) = std::get<1>(tup);
    }
};


template<size_t TruncSize, class Tup> struct th2;

//modifications to this class change "type" to the new truncated tuple type
//as well as modifying the template arguments to assign

template<size_t TruncSize, class Head, class... Tail>
struct th2<TruncSize, std::tuple<Head, Tail...>> 
{
    typedef typename tuple_trunc<TruncSize, std::tuple<Head, Tail...>>::type type;

    static type tail(const std::tuple<Head, Tail...>& tup) 
    {
        type t;
        assign<TruncSize, std::tuple_size<type>::value>::x(t, tup);
        return t;
    }
};

template<size_t TruncSize, class Tup>
typename th2<TruncSize, Tup>::type tail(const Tup& tup) 
{
    return th2<TruncSize, Tup>::tail(tup);
}

//a small example
int main()
{
    std::tuple<double, double, int, double> test(1, 2, 3, 4);
    tuple_trunc<2, std::tuple<double, double, int, double>>::type c = tail<2>(test);
    return 0;
}

Bitte nicht verwenden!

• Dies ist [wahrscheinlich] nicht spezifiziert Verhalten. Es könnte aufhören zu arbeiten, jederzeit.
• Darüber hinaus gibt es die Möglichkeit der Polsterung Probleme (d.h. es kann Arbeit für int aber kann fehlschlagen, für Ihre Art!).

Siehe Anmerkungen zur Diskussion. Ich lasse diese Antwort ist nur für Referenz.

Sogar noch einfacher:

tuple<int,int,int> origin{7,12,42};
tuple<int, int> &tail1 = (tuple<int, int>&)origin;
tuple<int> &tail2 = (tuple<int>&)origin;
cout << "tail1: {" << get<0>(tail1) << ", " << get<1>(tail1) << "}" << endl;
cout << "tail2: {" << get<0>(tail2) << "}" << endl;

Bekam ich:

tail1: {12, 42}
tail2: {42}

Ich bin nicht sicher, dass dies nicht eine unbestimmte Verhalten. Für mich funktioniert: Fedora 20 und

❯ clang --version
clang version 3.3 (tags/RELEASE_33/final)
Target: x86_64-redhat-linux-gnu
Thread model: posix
❯ gcc --version
gcc (GCC) 4.8.2 20131212 (Red Hat 4.8.2-7)
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Referenzen: Artikel auf voidnish.wordpress.com/.