make_unique und perfekte Weiterleitung

Warum gibt es std::make_uniquein der Standard-C ++ 11-Bibliothek keine Funktionsvorlage? ich finde

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

ein bisschen ausführlich. Wäre das Folgende nicht viel schöner?

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

Dies verbirgt das newschön und erwähnt den Typ nur einmal.

Wie auch immer, hier ist mein Versuch einer Implementierung von make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Ich habe eine ganze Weile std::forwardgebraucht, um das Zeug zu kompilieren, aber ich bin mir nicht sicher, ob es richtig ist. Ist es? Was genau bedeutet std::forward<Args>(args)...das? Was macht der Compiler daraus?

Herb Sutter, Vorsitzender des C ++ - Standardisierungsausschusses, schreibt in seinem Blog :

Dass C ++ 11 nicht enthalten make_uniqueist, ist teilweise ein Versehen und wird mit ziemlicher Sicherheit in Zukunft hinzugefügt.

Er gibt auch eine Implementierung an, die mit der vom OP angegebenen identisch ist.

Bearbeiten: std::make_unique Jetzt ist Teil von C ++ 14 .

Schön, aber Stephan T. Lavavej (besser bekannt als STL) hat eine bessere Lösung für make_unique, die für die Array-Version korrekt funktioniert.

#include <memory>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::false_type, Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::true_type, Args&&... args) {
   static_assert(std::extent<T>::value == 0,
       "make_unique<T[N]>() is forbidden, please use make_unique<T[]>().");

   typedef typename std::remove_extent<T>::type U;
   return std::unique_ptr<T>(new U[sizeof...(Args)]{std::forward<Args>(args)...});
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
   return make_unique_helper<T>(std::is_array<T>(), std::forward<Args>(args)...);
}

Dies ist auf seinem Core C ++ 6-Video zu sehen .

Eine aktualisierte Version der STL-Version von make_unique ist jetzt als N3656 verfügbar . Diese Version wurde in den Entwurf von C ++ 14 übernommen.

std::make_sharedist nicht nur eine Abkürzung für std::shared_ptr<Type> ptr(new Type(...));. Es macht etwas, was man ohne es nicht machen kann.

Um seine Arbeit zu erledigen, std::shared_ptrmuss zusätzlich zum Speichern des Speichers für den eigentlichen Zeiger ein Verfolgungsblock zugewiesen werden. Da jedoch std::make_shareddas tatsächliche Objekt zugewiesen wird, ist es möglich, dass std::make_sharedsowohl das Objekt als auch der Verfolgungsblock in demselben Speicherblock zugewiesen werden .

Während std::shared_ptr<Type> ptr = new Type(...);also zwei Speicherzuordnungen (eine für die new, eine im std::shared_ptrVerfolgungsblock) vorhanden std::make_shared<Type>(...)wären , würde ein Speicherblock zugewiesen .

Das ist wichtig für viele potentielle Nutzer von std::shared_ptr. Das einzige, was ein std::make_uniquetun würde, ist etwas bequemer. Nichts weiter als das.

Nichts hindert Sie daran, Ihren eigenen Helfer zu schreiben, aber ich glaube, dass der Hauptgrund für die Bereitstellung make_shared<T>in der Bibliothek darin besteht, dass tatsächlich ein anderer interner Typ eines gemeinsam genutzten Zeigers erstellt wird als der shared_ptr<T>(new T), der anders zugewiesen ist, und es gibt keine Möglichkeit, dies ohne den dedizierten zu erreichen Helfer.

Ihr make_uniqueWrapper hingegen ist nur syntaktischer Zucker um einen newAusdruck. Während er für das Auge angenehm aussieht, bringt er nichts newauf den Tisch. Korrektur: Dies ist in der Tat nicht der Fall: Ein Funktionsaufruf zum Umschließen des newAusdrucks bietet Ausnahmesicherheit, beispielsweise in dem Fall, in dem Sie eine Funktion aufrufen void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Wenn zwei newRaws in Bezug aufeinander nicht sequenziert sind, bedeutet dies, dass der andere Ressourcen möglicherweise ausläuft, wenn ein neuer Ausdruck mit einer Ausnahme fehlschlägt. Warum es make_uniqueim Standard kein gibt : Es wurde einfach vergessen. (Dies kommt gelegentlich vor. Es gibt auch kein globales Element std::cbeginim Standard, obwohl es eines geben sollte.)

Beachten Sie auch, dass unique_ptrein zweiter Vorlagenparameter erforderlich ist, den Sie irgendwie berücksichtigen sollten. Dies unterscheidet sich von shared_ptrder Verwendung der Typlöschung zum Speichern benutzerdefinierter Löscher, ohne sie zum Teil des Typs zu machen.

In C ++ wird 11 ...(im Vorlagencode) auch für die "Pack-Erweiterung" verwendet.

Voraussetzung ist, dass Sie es als Suffix eines Ausdrucks verwenden, der ein nicht erweitertes Paket von Parametern enthält, und dass der Ausdruck einfach auf jedes der Elemente des Pakets angewendet wird.

Bauen Sie zum Beispiel auf Ihrem Beispiel auf:

std::forward<Args>(args)... -> std::forward<int>(1), std::forward<int>(2),
                                                     std::forward<int>(3)

std::forward<Args...>(args...) -> std::forward<int, int, int>(1,2,3)

Letzteres ist falsch, denke ich.

Außerdem kann ein Argumentpaket nicht an eine nicht erweiterte Funktion übergeben werden. Ich bin mir über ein Paket von Vorlagenparametern nicht sicher.

Inspiriert von der Implementierung von Stephan T. Lavavej fand ich es vielleicht schön, ein make_unique zu haben, das Array-Extents unterstützt. Es ist auf Github und ich würde gerne Kommentare dazu bekommen. Damit können Sie Folgendes tun:

// create unique_ptr to an array of 100 integers
auto a = make_unique<int[100]>();

// create a unique_ptr to an array of 100 integers and
// set the first three elements to 1,2,3
auto b = make_unique<int[100]>(1,2,3);