Einfügen einer Variable argument-Liste in einen Vektor?

Verzeihen Sie mir, wenn dies wurde bereits beantwortet, als ich konnte ihn nicht finden...

Grundsätzlich habe ich ein Objekt treffen muss, um eine Variable argument-Liste im Konstruktor und speichert die Argumente, die in einem Vektor. Wie kann ich die initialisieren einen Vektor von einem der Argumente eine Variable Konstruktor?

class GenericNode {
public:
    GenericNode(GenericNode*... inputs) {
            /* Something like... */
        //inputs_.push_back(inputs)...;
}
private:
    std::vector<GenericNode*> inputs_;
};
  • Es gibt einige ungültige syntax in deinem Beispiel. Was genau versuchst du zu Fragen?
  • verwenden std::initializer_list<GenericNode*>.
  • Sorry. Um zu klären, wie verwende ich die argument-Liste zu füllen std::vector? @MooingDuck, guck ich in die std::initializer_list. Danke.
InformationsquelleAutor fredbaba | 2012-12-20
  1. 25

    Den besten Sache wäre die Verwendung einer Initialisierungsliste

    #include <initializer_list>
#include <vector>
class GenericNode {
public:
    GenericNode(std::initializer_list<GenericNode*> inputs) 
        :inputs_(inputs) {} //well that's easy
private:
    std::vector<GenericNode*> inputs_;
};
int main() {
    GenericNode* ptr;
    GenericNode node{ptr, ptr, ptr, ptr};
} //compilation at http://stacked-crooked.com/view?id=88ebac6a4490915fc4bc608765ba2b6c

    Dem am nächsten, was Sie bereits haben, mit C++11 ist die Verwendung des Vektors initializer_list:

        template<class ...Ts>
    GenericNode(Ts... inputs) 
        :inputs_{inputs...} {} //well that's easy too
    //compilation at http://stacked-crooked.com/view?id=2f7514b33401c51d33677bbff358f8ae

    Und hier ist ein C++11-version ohne initializer_lists überhaupt. Es ist hässlich und kompliziert und erfordert Funktionen fehlt vielen Compilern. Verwenden Sie die Initialisierungsliste

    template<class T>
using Alias = T;

class GenericNode {
public:
    template<class ...Ts>
    GenericNode(Ts... inputs) { //SFINAE might be appropriate
         using ptr = GenericNode*;
         Alias<char[]>{( //first part of magic unpacker
             inputs_.push_back(ptr(inputs))
             ,'0')...,'0'}; //second part of magic unpacker
    }
private:
    std::vector<GenericNode*> inputs_;
};
int main() {
    GenericNode* ptr;
    GenericNode node(ptr, ptr, ptr, ptr);
} //compilation at http://stacked-crooked.com/view?id=57c533692166fb222adf5f837891e1f9
//thanks to R. Martinho Fernandes for helping me get it to compile

    Unabhängig von alles, was, die ich weiß nicht, ob diejenigen sind, besitzen die Zeiger oder nicht. Wenn Sie sind, verwenden Sie std::unique_ptr statt.

    • Würde nicht template<typename... T> GenericNode(T*... inputs) :inputs_{ inputs... } { } näher zu dem, was er bereits hat? ich gehe immer noch mit std::initializer_list<GenericNode*> obwohl.
    • Keine Ahnung, warum ich noch nie gedacht. Behoben.
    • andere: vielen Dank. Genau das, was ich brauchte.
    • Abgesehen von der Antwort selbst, und abgesehen davon, ob es praktisch ist oder nicht, ich finde deine 3. Lösung sehr clever. Gibt es eine Anleitung irgendwo erklärt den Grund für die einzelnen Stücke? Speziell, warum die Notwendigkeit für Alias, und warum die Notwendigkeit für die Letzte '0' Wert?
    • Ich eigentlich kopieren-einfügen von einem anderen Antwort, die ich gesehen hatte, der andere SO beantworten irgendwo. Der alias wird benötigt, um ein namenloses temporäres array, das macht es offenkundig an jedem compiler, dass es nicht wirklich brauchen, um das array von chars. Für jede Ts es fügt eine '0' auf das array. Allerdings, wenn Sie keine Eingänge, das ist das gleiche wie char t[] = {} ungültig, so dass wir tack auf einem extra '0' so gibt es immer mindestens ein element in das temporäre array.
    • genial, vielen Dank
    • Downvote für nicht zu erwähnen, umfasst.
    • Scheint hart. Ich beantwortet die Frage vollständig, kann der Leser trivial herauszufinden, die gehören sich selbst. Unabhängig: Hinzugefügt.
    • Ist die Dritte Lösung, die garantiert zu erhalten, um?
    • Ehrlich gesagt, kann ich mich nicht erinnern. Ich habe irgendwie daran erinnern, dass die ... ist garantiert Auspacken in Ordnung, aber ich würde nicht schwören, dass es so ist.
    • wenn ich mich richtig erinnere, ist es garantiert, da c++17. So, hier ist eine bessere Lösung für c++ < 17: stackoverflow.com/a/33747281/3993308
    • Und in c++17, es sind Falten Ausdruck für diese Art von Aufgaben.

    InformationsquelleAutor Mooing Duck
  2. 6
        //inputs_.push_back(inputs)...;

    Funktioniert das nicht, weil Sie nicht erweitern kann ein parameter-pack als eine Aussage, die nur in bestimmten Kontexten wie eine Funktion argument-Liste oder der Initialisierer-Liste.

    Auch Ihr Konstruktor Signatur ist falsch, wenn Sie versuchen zu schreiben, ein variadic template muss es eine Vorlage!

    Wenn Sie schreiben, Ihr Konstruktor Signatur richtig, die Antwort ist einfach: konstruieren Sie den Vektor mit dem expansion pack:

    #include <vector>

class GenericNode
{
public:
  template<typename... T>
    GenericNode(T*... inputs) : inputs_{ inputs... }
    { }
private:
    std::vector<GenericNode*> inputs_;
};

    (Man könnte stattdessen haben Sie in den Konstruktor Körper mit:

    inputs_ = { inputs... };

    aber die coolen kids member-Initialisierungen nicht Zuweisung im Konstruktor Körper.)

    Der Nachteil dieser Lösung ist, dass die template-Konstruktor akzeptiert jede Art von Zeiger-Argumente an, wird dann aber zu einem Fehler, wenn Sie versuchen zu bauen, Vektor, wenn die Argumente sind nicht konvertierbar GenericNode*. Sie könnte fixieren Sie die Vorlage nur annehmen GenericNode Zeiger, aber das ist, was geschieht automatisch, wenn Sie das tun, was die anderen Antworten vorschlagen und machen den Konstruktor nehmen std::initializer_list<GenericNode*>, und dann Sie brauchen keine hässlichen enable_if SFINAE tricks.

    InformationsquelleAutor Jonathan Wakely
  3. 2

    Können Sie nicht verwenden Sie eine Variable Argumentliste, es sei denn, es ist eine Vorlage, Sie können, wie gesagt, verwenden Sie eine initializer_list wie diese:

    class GenericNode {
public:
    GenericNode(std::initializer_list<GenericNode*> inputs) : inputs_(inputs)
    {
    }
private:
    std::vector<GenericNode*> inputs_;
};

template <class ... T>
GenericNode* foo(T ... t)
{
    return new GenericNode({t...});
}
    • Warum haben Sie die helper-Funktion?
    • Nur um zu zeigen, den Einsatz von variadic template-Parameter
    InformationsquelleAutor Luke B.
  4. 1

    Anderen Weg, es zu tun:

    #include <iostream>
#include <vector>

using std::vector;

template <typename T>
void variadic_vector_emplace(vector<T>&) {}

template <typename T, typename First, typename... Args>
void variadic_vector_emplace(vector<T>& v, First&& first, Args&&... args)
{
    v.emplace_back(std::forward<First>(first));
    variadic_vector_emplace(v, std::forward<Args>(args)...);
}

struct my_struct
{
    template <typename... Args>
    my_struct(Args&&... args)
    {
        variadic_vector_emplace(_data, std::forward<Args>(args)...);
    }

    vector<int>& data() { return _data; }

private:
  vector<int> _data;
};


int main()
{
    my_struct my(5, 6, 7, 8);

    for(int i : my.data())
      std::cout << i << std::endl;
}
    InformationsquelleAutor Gigi
  5. 1
    class Blob
 {
    std::vector<std::string> _v;
 public:

    template<typename... Args>
    Blob(Args&&... args)
    : _v(std::forward<Args>(args)...)
    {  }

};

int main(void)
{
    const char * shapes[3] = { "Circle", "Triangle", "Square" };

    Blob b1(5, "C++ Truths"); 
    Blob b2(shapes, shapes+3);
}

    Beispiel von C++11 Wahrheiten sieht einfach genug...;)
    Keine vollständige Lösung, aber könnte Ihnen einige Ideen.

    • Dies funktioniert ok, für Ihren b1 und b2 Beispiele, aber die OP machen will Blob b3{ "Circle", "Triangle", "Square" }; und Ihre Blob Konstruktor kann das nicht tun, weil Sie Wert-Initialisierung für _v. Wenn Sie es ändern, verwenden list-Initialisierung für _v es unterstützen würde, was der OP machen will.
    InformationsquelleAutor Mattias
  6. 0

    Ich schrieb vor kurzem die folgende Funktion, die einen string mit
    {1} , {2} , {3} ... in es und ersetzt die Liste von Argumenten. Ich lief in das gleiche problem, bis ich beschlossen, damit der compiler work it out für sich selbst mit dem auto-keyword. 

    #include <string>
#include <vector>

using std::string;
using std::vector;

template<typename S, typename... Args>
string interpolate( const S& orig , const Args&... args)
{
   string out(orig);

   auto va = {args...};
   vector<string> v{va};

   size_t i = 1;

   for( string s: v)
    {
      string is = std::to_string(i);
      string t = "{" +  is + "}";
      try
         {
           auto pos = out.find(t);
           if(pos != out.npos) 
              {
                 out.erase(pos, t.length());
                 out.insert( pos, s); 
              }                  
           i++;
         }
    catch( std::exception& e)
       {
          std::cerr << e.what() << std::endl;
       }
     } //for

   return out;
 }

    Das ist scheinbar gut genug, solange die Arten line-up richtig.
    In diesem Fall verwende ich nur std::string ganz.
    Ich denke, das ist eine elegante Technik, aber es kann Nachteile haben.

    InformationsquelleAutor Chris Reid
Schreibe einen Kommentar