make_shared (<memory>)
Erstellt shared_ptr, das auf die zugeordneten Objekte, die mithilfe der Standardbelegung von keinen oder mehreren Argumenten erstellt werden, oder gibt es zurück. Weist sowohl ein Objekt des angegebenen Typs als auch shared_ptr zu und erstellt sie, um die Freigabe des Objekts zu verwalten, und gibt shared_ptr zurück.
template<class Type, class... Types> shared_ptr<Type> make_shared( Types&&... _Args );
Parameter
Parameter |
Beschreibung |
|---|---|
_Args |
Null oder mehr Konstruktorargumente. Die Funktion leitet auf Grundlage der bereitgestellten Argumente die erforderliche die Konstruktorüberladung ab. |
Eigenschaftswert/Rückgabewert
Gibt shared_ptr zurück, das auf das zugeordnete und erstellte Objekt verweist.
Hinweise
Verwenden Sie make_shared als einfache und effizientere Möglichkeit, um ein Objekt und shared_ptr zu erstellen, um den gemeinsamen, gleichzeitigen Zugriff auf das Objekt zu verwalten. Semantisch gesehen sind diese beiden Anweisungen äquivalent:
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
Die erste Anweisung ergibt jedoch zwei Zuordnungen, und wenn die Zuordnung von shared_ptr fehlschlägt, nachdem die Zuordnung des Example-Objekts erfolgreich war, geht das unbenannte Example-Objekt verloren. Die Anweisung, die make_shared verwendet, ist einfacher, da nur ein Funktionsaufruf beteiligt ist. Sie ist effizienter, da die Bibliothek eine einzige Zuordnung für das Objekt und den intelligenten Zeiger vornehmen kann. Dies ist schneller und führt zu einer geringeren Speicherfragmentierung; zudem kann es nicht bei nur einer Zuordnung zu einer Ausnahme kommen. Die Leistung wird durch einen besseren Speicherort für den Code verbessert, der auf das Objekt verweist und den Verweiszähler im intelligenten Zeiger aktualisiert.
Ziehen Sie die Verwendung von make_unique in Betracht, wenn Sie keinen gemeinsamen Zugriff auf das Objekt benötigen. Verwenden Sie allocate_shared, wenn Sie eine benutzerdefinierte Zuweisung für das Objekt angeben müssen. Sie können make_shared nicht verwenden, wenn das Objekt einen benutzerdefinierten Deleter benötigt, da es keine Möglichkeit gibt, den Deleter als Argument zu übergeben.
Im folgenden Beispiel wird die Erstellung freigegebener Zeiger auf einen Typ mithilfe bestimmter Konstruktorüberladungen veranschaulicht.
Beispiel
// stl_make_shared.cpp
// Compile by using: cl /W4 /EHsc stl_make_shared.cpp
#include <iostream>
#include <string>
#include <memory>
#include <vector>
class Song {
public:
std::wstring title_;
std::wstring artist_;
Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist) {}
Song(std::wstring title) : title_(title), artist_(L"Unknown") {}
};
void CreateSharedPointers() {
// Okay, but less efficient to have separate allocations for
// Song object and shared_ptr control block.
auto song = new Song(L"Ode to Joy", L"Beethoven");
std::shared_ptr<Song> sp0(song);
// Use make_shared function when possible. Memory for control block
// and Song object are allocated in the same call:
auto sp1 = std::make_shared<Song>(L"Yesterday", L"The Beatles");
auto sp2 = std::make_shared<Song>(L"Blackbird", L"The Beatles");
// make_shared infers which constructor to use based on the arguments.
auto sp3 = std::make_shared<Song>(L"Greensleeves");
// The playlist vector makes copies of the shared_ptr pointers.
std::vector<std::shared_ptr<Song>> playlist;
playlist.push_back(sp0);
playlist.push_back(sp1);
playlist.push_back(sp2);
playlist.push_back(sp3);
playlist.push_back(sp1);
playlist.push_back(sp2);
for (auto&& sp : playlist) {
std::wcout << L"Playing " << sp->title_ <<
L" by " << sp->artist_ << L", use count: " <<
sp.use_count() << std::endl;
}
}
int main() {
CreateSharedPointers();
}
Das Beispiel generiert die folgende Ausgabe:
Anforderungen
Header: <memory>
Namespace: std