c++ : konvertieren Sie vector-Tupel

Wie kann ich umwandeln std::vector std::tuple ?
Ich habe 

class T { };
int cnt = 3;
vector<T*> tv;
for (int i = 0; i < cnt; ++i) {
  tv.push_back(new T());
}

Ich will

auto tp = std::tie(*tv[0], *tv[1], *tv[2]);

Wie kann ich diese tp ?
Wenn cnt ist groß genug, ich kann nicht schreiben, diese tp manuell.

  std::vector<
  ConvConnection<
  decltype(inputLayer),
  decltype(*C1[0]),
  decltype(*Conn1Opt[0]),
  RandomInitialization<arma::mat>,
  arma::mat
  >* > Conn1(6);

  for (size_t i = 0; i < 6; ++i) {
    Conn1.push_back(new  ConvConnection<
                    decltype(inputLayer),
                    decltype(*C1[0]),
                    decltype(*Conn1Opt[0]),
                    RandomInitialization<arma::mat>,
                    arma::mat
                    >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5));
  }

Dies ist der code. Hier ist nur 6, aber ich brauche auch ein Vektor, dessen Größe über 100. Ich brauche zum konvertieren dieser Vektor auf ein Tupel.

  • Wenn es zu groß oder zu mühsam zu schreiben, manuell, schreiben Sie ein weiteres Programm, das es erzeugt. Wenn Sie möchten, um zu bestimmen, die Tupel Größe zur Laufzeit können Sie nicht.
  • Warum brauchen Sie ein Tupel? Würde nicht std::array<T*,MAX> Arbeit?
  • Einen off-topic-Fehler: Man sollte wirklich besser eine variable/Klasse Namen. Es gibt keinen Grund cnt kann nicht geschrieben werden als count. Was ist ein ConvConnection? Conn1Opt? Im Jahr 2015, Ihre source-Dateien werden immer noch auf Ihrer Festplatte mit ein paar zusätzliche Zeichen in Ihnen, und andere Entwickler, die sich Ihr code wird es dir danken später 🙂
InformationsquelleAutor Shangtong Zhang | 2015-02-09
  1. 15

    Im Allgemeinen, Sie können nicht konvertieren eine vector zu einem tuple. Allerdings, wenn alles, was Sie versuchen zu tun ist stellen Sie die Tupel <f(0), f(1), ..., f(N-1)> für einige N ist ein konstanter Ausdruck ist, dann ist das machbar mit der index-Sequenz trick:

    template <typename F, size_t... Is>
auto gen_tuple_impl(F func, std::index_sequence<Is...> ) {
    return std::make_tuple(func(Is)...);
}

template <size_t N, typename F>
auto gen_tuple(F func) {
    return gen_tuple_impl(func, std::make_index_sequence<N>{} );
}

    Die wir nutzen können wie:

    //make a tuple of the first 10 squares: 0, 1, 4, ..., 81
auto squares = gen_tuple<10>([](size_t i){ return i*i;});

    Für Ihren speziellen Anwendungsfall, das wäre:

    auto connections = gen_tuple<6>([&](size_t i) {
    return new ConvConnection<
                decltype(inputLayer),
                decltype(*C1[0]),
                decltype(*Conn1Opt[0]),
                RandomInitialization<arma::mat>,
                arma::mat
                >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5);
});
    • Danke. Aber ich brauche Tupel <T1, T2, .... TN> wobei jedes Ti ist eine Klasse. Ich benutze diese, um ein neuronales Netzwerk. Denn die aktuellen Rahmenbedingungen des NN verwendet Tupel, aber jetzt ist mein Netzwerk ist zu groß, dass ich es schreiben können manuell. Es scheint, muss ich verändern, Rahmen oder generieren Sie ein anderes Programm verwenden.
    • Sie können dies tun, mit Klassen zu. Ersetzen Sie einfach make_tuple(Is...) mit make_tuple(new T(Is)...).
    • Update ich die Frage und gebe meine echten code. Jede Klasse in dem Tupel hat verschiedene parameter für den Bau. Können Sie mir helfen mit diesem?
    • Aktualisiert meine Antwort zu ermöglichen, eine Funktion, die Sie übergeben können.
    InformationsquelleAutor Barry
  2. 10

    Wenn Sie C++14, Sie können es so machen:

    template <typename T, std::size_t... Indices>
auto vectorToTupleHelper(const std::vector<T>& v, std::index_sequence<Indices...>) {
  return std::make_tuple(v[Indices]...);
}

template <std::size_t N, typename T>
auto vectorToTuple(const std::vector<T>& v) {
  assert(v.size() >= N);
  return vectorToTupleHelper(v, std::make_index_sequence<N>());
}

    Dank " auto-Abzug, das ist ok. In C++11, ohne automatischen Abzug, schreiben Sie die return-Typen trailing decltype. Sie haben auch, um Ihre eigenen index_sequence.

    InformationsquelleAutor Sebastian Redl
  3. 6

    Kann man einfach nicht. Da der Vektor Größe ist zur Laufzeit bekannt, aber tuple Art (auch seiner Größe) muss zur Kompilierzeit bekannt ist.

    • Dann, wie kann ich eine "große" Tupel ? Ich will auto tp = std::tie(T1, T2, T3, ..... TN) Angenommen N ist groß genug, ich habe zu generieren T1 ... TN dynamisch. Angenommen, N ist behoben, wenn ich code schreiben.
    • was ist die 'großen' Tupel?
    InformationsquelleAutor bolov
Schreibe einen Kommentar