Aufruf initializer_list Konstruktor über make_unique/make_shared

Ich versuche zu verwenden std::make_unique instantiieren einer Klasse, deren Konstruktor erhalten, der eine std::initializer_list. Hier ein minimal-Fall :

#include <string>
#include <vector>
#include <initializer_list>
#include <memory>

struct Foo {
    Foo(std::initializer_list<std::string> strings) : strings(strings) {}

    std::vector<std::string> strings;
};

int main(int, char**) {

    auto ptr = std::make_unique<Foo>({"Hello", "World"});

    return 0;
}

Sehen Sie auf Coliru, dass es nicht bauen :

main.cpp:14:56: error: no matching function for call to 'make_unique(<brace-enclosed initializer list>)'
     auto ptr = std::make_unique<Foo>({"Hello", "World"});

So, ist make_unique angeblich nicht in der Lage zu verwenden initializer_lists ? Ist es ein bug in GCC 4.9.1 ? Oder hab ich was übersehen ?

Verspannt Listen nicht abgeleitet werden kann durch das template-argument Abzug. Versuchen make_unique<Foo>(std::initializer_list<std::string>({"Hello", "World"})).
Gut, das sieht aus wie eine Antwort für mich 🙂
Hm, funktioniert das, und hilft es?
Ja, es funktioniert ! Aber pfui, die syntax. initializer_lists sind definitiv seltsame Dinge. In diesem besonderen Fall, ich denke, ich werde einfach zu konstruieren, das unique_ptr aus einer new nennen.
Das ist schade, aber verständlich. std::initializer_list ist eine schreckliche misdesign. Tut mir Leid, dass.

InformationsquelleAutor Quentin | 2014-10-15

  1. 30

    std::make_unique ist eine Funktion, die Vorlage, die leitet die argument-Typen, die übergeben werden, um die Objekt-Konstruktor. Leider, verspannt-Listen sind nicht ableitbar (mit einer Ausnahme für auto Erklärungen), so Sie kann nicht instanziiert die Funktion Vorlage, wenn Sie, dass fehlende parameter Typ.

    Können Sie entweder nicht verwenden std::make_unique, aber bitte nicht diesen Weg gehen – Sie sollten es vermeiden, nackt news so viel wie Sie können, für die Kinder Willen. Oder Sie können die Art Abzug arbeiten durch Angabe des Typs:

    • std::make_unique<Foo>(std::initializer_list<std::string>({"Hello", "World"}))

    • std::make_unique<Foo, std::initializer_list<std::string>>({"Hello", "World"})

    • auto il = { "Hello"s, "World"s }; auto ptr = std::make_unique<Foo>(il);

    Die Letzte option verwendet die spezielle Regel für auto Erklärungen, die (wie ich angedeutet oben) tun in der Tat Rückschlüsse auf eine std::initializer_list.

    InformationsquelleAutor Kerrek SB

  2. 3

    Wenn Sie bereit sind, geben Sie ein paar zusätzliche Zeichen, die Sie dies tun können:

    auto ptr = std::make_unique<Foo>( make_init_list( { "Hello"s , "World"s } ));

    wo init_list ist definiert als

    template<typename T>
std:: initializer_list<T> make_init_list ( std:: initializer_list<T> && l ) {
    return l;
}

    Dies ermöglicht, den Abzug zu erfolgen, und ist praktisch, wenn es gibt viele stellen im code müssen Sie dies tun.

    (Funktioniert auch mit clang 3.9 und gcc-6.2.0. Ich habe es auf der Arbeit auf g++-4.8.4 auch, außer ich hatte zu zwicken std::string-literal und ändern zu make_shared. Aber der Abzug von T innerhalb make_init_list fein gearbeitet.)

    Eigentlich ist es zu dieser Erweiterung? Erfolgreich ist der Abzug für make_init_list von der Norm geforderten oder nicht?

    InformationsquelleAutor Aaron McDaid

Schreibe einen Kommentar