Namensräume
Varianten
Aktionen

std::shared_ptr::shared_ptr

Aus cppreference.com
< cpp‎ | memory‎ | shared ptr

 
 
 
Dynamische Speicherverwaltung
Low-Level-Speicherverwaltung
Zuweiser
Original:
Allocators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
allocator
allocator_traits(C++11)
allocator_arg_t(C++11)
allocator_arg(C++11)
uses_allocator(C++11)
scoped_allocator_adaptor(C++11)
Initialisierter Speicher
Original:
Uninitialized storage
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
uninitialized_copy
uninitialized_copy_n(C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Intelligente Zeiger
Original:
Smart pointers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
unique_ptr(C++11)
shared_ptr(C++11)
weak_ptr(C++11)
auto_ptr(veraltet)
owner_less(C++11)
enable_shared_from_this(C++11)
bad_weak_ptr(C++11)
default_delete(C++11)
Garbage Collection Unterstützung
Original:
Garbage collection support
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
declare_reachable(C++11)
undeclare_reachable(C++11)
declare_no_pointers(C++11)
undeclare_no_pointers(C++11)
pointer_safety(C++11)
get_pointer_safety(C++11)
Verschiedenes
Original:
Miscellaneous
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pointer_traits(C++11)
addressof(C++11)
align(C++11)
C-Bibliothek
Original:
C Library
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
 
std::shared_ptr
Member-Funktionen
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::shared_ptr
shared_ptr::~shared_ptr
shared_ptr::operator=
Modifiers
Original:
Modifiers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::reset
shared_ptr::swap
Beobachter
Original:
Observers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::get
shared_ptr::operator*
shared_ptr::operator->
shared_ptr::use_count
shared_ptr::unique
shared_ptr::operator bool
shared_ptr::owner_before
Non-Member-Funktionen
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::swap
make_shared
allocate_shared
static_pointer_cast
dynamic_pointer_cast
const_pointer_cast
get_deleter
operator==
operator|=
operator<
operator<=
operator>
operator>=
operator<<
atomic_is_lock_free
atomic_load
atomic_load_explicit
atomic_store
atomic_store_explicit
atomic_exchange
atomic_exchange_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_strong
atomic_compare_exchange_weak_explicit
atomic_compare_exchange_strong_explicit
std::hash
 
constexpr shared_ptr();
(1)
template< class Y >
explicit shared_ptr( Y* ptr );
(2)
template< class Y, class Deleter >
shared_ptr( Y* ptr, Deleter d );
(3)
template< class Y, class Deleter, class Alloc >
shared_ptr( Y* ptr, Deleter d, Alloc alloc );
(4)
constexpr shared_ptr( std::nullptr_t );
(5)
template< class Deleter >
shared_ptr( std::nullptr_t, Deleter d );
(6)
template< class Deleter, class Alloc >
shared_ptr( std::nullptr_t, Deleter d, Alloc alloc );
(7)
template< class Y >
shared_ptr( const shared_ptr<Y>& r, T *ptr );
(8)
shared_ptr( const shared_ptr& r );
(9)
template< class Y >
shared_ptr( const shared_ptr<Y>& r );
(9)
shared_ptr( shared_ptr&& r );
(10)
template< class Y >
shared_ptr( shared_ptr<Y>&& r );
(10)
template< class Y >
explicit shared_ptr( const std::weak_ptr<Y>& r );
(11)
template< class Y >
shared_ptr( std::auto_ptr<Y>&& r );
(12)
template< class Y, class Deleter >
shared_ptr( std::unique_ptr<Y,Deleter>&& r );
(13)
Konstrukte neue shared_ptr aus einer Vielzahl von Typen Zeiger auf ein Objekt zur Verwaltung beziehen. Optional deleter d zugeführt werden kann, die später verwendet werden, um das Objekt zu zerstören, wenn keine shared_ptr Objekte, die es zu besitzen. Standardmäßig wird Löschen Ausdruck Ausdruck als deleter verwendet. Proper delete Ausdruck, der dem bereitgestellten Typ immer gewählt wird, ist dies der Grund, warum die Konstrukteure als Vorlagen mit einem separaten Parameter Y umgesetzt werden .
Original:
Constructs new shared_ptr from a variety of pointer types that refer to an object to manage. Optional deleter d can be supplied, which is later used to destroy the object when no shared_ptr objects own it. By default, Löschen Ausdruck expression is used as deleter. Proper delete expression corresponding to the supplied type is always selected, this is the reason why the constructors are implemented as templates using a separate parameter Y.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Wenn das Objekt, auf das ptr wird bereits von einigen gemeinsamen Zeiger, die Konstruktor Ergebnisse in undefinierten Verhalten gehört .
Original:
If the object pointed to by ptr is already owned by some shared pointer, the constructor results in undefined behavior.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Standardkonstruktor erstellt eine shared_ptr ohne verwaltetes Objekt, dh leer shared_ptr
Original:
Default constructor constructs a shared_ptr with no managed object, i.e. empty shared_ptr
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2-4)
Erzeugt ein shared_ptr mit ptr als verwaltetes Objekt. Y muss eine vollständige Art und implizit konvertierbar T sein. Zusätzlich:
Original:
Constructs a shared_ptr with ptr as the managed object. Y must be a complete type and implicitly convertible to T. Additionally:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Verwendet die delete-Ausdruck als deleter. Eine gültige löschen Ausdruck muss verfügbar sein, dh delete ptr müssen gut ausgebildet sein, genau definierte Verhalten und nicht werfen keine Ausnahmen .
Original:
Uses the delete expression as the deleter. A valid delete expression must be available, i.e. delete ptr must be well formed, have well-defined behavior and not throw any exceptions.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Verwendet die angegebene deleter d als deleter. Deleter muss für die Art kündbare T, dh d(ptr) müssen gut geformt sein, genau definierte Verhalten und nicht werfen keine Ausnahmen. Deleter müssen CopyConstructible sein .
Original:
Uses the specified deleter d as the deleter. Deleter must be callable for the type T, i.e. d(ptr) must be well formed, have well-defined behavior and not throw any exceptions. Deleter must be CopyConstructible.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Gleich wie (3), sondern nutzt zusätzlich eine Kopie des alloc für die Zuweisung von Daten für den internen Gebrauch. Alloc muss ein Allocator sein. Der Copy-Konstruktor und Destruktor dürfen keine Ausnahmen auslösen .
Original:
Same as (3), but additionally uses a copy of alloc for allocation of data for internal use. Alloc must be a Allocator. The copy constructor and destructor must not throw exceptions.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5-7)
Analog zu (2), (3), (4) jeweils, aber konstruiert ein shared_ptr ohne verwaltetes Objekt, dh leere shared_ptr .
Original:
Analogous to (2), (3), (4) respectively, but constructs a shared_ptr with no managed object, i.e. empty shared_ptr.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Erzeugt ein shared_ptr die Eigentumsverhältnisse Aktien mit r, hält aber eine unabhängige und nicht verwalteter Zeiger ptr. Auch wenn diese shared_ptr ist die letzte der Gruppe zu gehen out of scope, wird es den Destruktor für das Objekt ursprünglich von r verwaltet nennen. Allerdings wird beim Aufrufen get() dazu immer wieder eine Kopie des ptr. Es liegt in der Verantwortung des Programmierers, sicherzustellen, dass diese ptr gültig bleibt, solange dies shared_ptr besteht, wie in den typischen Anwendungsfällen, wo ptr ist Mitglied des Objektes durch r verwaltet oder ist ein Alias ​​(zB niedergeschlagenen) der r.get()
Original:
Constructs a shared_ptr which shares ownership information with r, but holds an unrelated and unmanaged pointer ptr. Even if this shared_ptr is the last of the group to go out of scope, it will call the destructor for the object originally managed by r. However, calling get() on this will always return a copy of ptr. It is the responsibility of the programmer to make sure that this ptr remains valid as long as this shared_ptr exists, such as in the typical use cases where ptr is a member of the object managed by r or is an alias (e.g., downcast) of r.get()
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
9)
Erzeugt ein shared_ptr das Eigentum an dem Objekt durch r verwaltet Aktien. Wenn r kein Objekt verwaltet, verwaltet *this kein Objekt zu. Die Vorlagen Überlastung nicht in der Überladungsauflösung teilnehmen, wenn Y* nicht implizit konvertierbar T* .
Original:
Constructs a shared_ptr which shares ownership of the object managed by r. If r manages no object, *this manages no object too. The templated overload doesn't participate in the overload resolution if Y* is not implicitly convertible to T*.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
10)
Move-baut eine shared_ptr von r. Nach dem Bau, *this eine Kopie des vorherigen Zustand r enthält, r ist leer. Die Vorlagen Überlastung nicht in der Überladungsauflösung teilnehmen, wenn Y* nicht implizit konvertierbar T* .
Original:
Move-constructs a shared_ptr from r. After the construction, *this contains a copy of the previous state of r, r is empty. The templated overload doesn't participate in the overload resolution if Y* is not implicitly convertible to T*.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
11)
Erzeugt ein shared_ptr das Eigentum an dem Objekt durch r verwaltet Aktien. Y* müssen konvertierbar sein T*. Beachten Sie, dass r.lock() für den gleichen Zweck verwendet werden: Der Unterschied ist, dass dieser Konstruktor eine Ausnahme auslöst, wenn das Argument leer ist, während std::weak_ptr<T>::lock() eine leere std::shared_ptr in diesem Fall baut .
Original:
Constructs a shared_ptr which shares ownership of the object managed by r. Y* must be convertible to T*. Note that r.lock() may be used for the same purpose: the difference is that this constructor throws an exception if the argument is empty, while std::weak_ptr<T>::lock() constructs an empty std::shared_ptr in that case.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
12)
Erzeugt ein shared_ptr, dass und speichert das Objekt besitzt früher r Besitz. Y* müssen konvertierbar sein T*. Nach Konstruktion ist r leer .
Original:
Constructs a shared_ptr that stores and owns the object formerly owned by r. Y* must be convertible to T*. After construction, r is empty.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
13)
Erzeugt ein shared_ptr, die das Objekt derzeit von r verwaltet verwaltet. Die deleter zugeordneten r ist für zukünftige Deletion des verwalteten Objekts gespeichert. r verwaltet kein Objekt nach dem Aufruf. Y* müssen konvertierbar sein T* .
Original:
Constructs a shared_ptr which manages the object currently managed by r. The deleter associated to r is stored for future deletion of the managed object. r manages no object after the call. Y* must be convertible to T*.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Inhaltsverzeichnis

[Bearbeiten] Notes

Beim Bau von einem rohen Zeiger auf ein Objekt eines Typs aus std::enable_shared_from_this abgeleitet, erkennen die Konstrukteure von shared_ptr anderen Eigentümern des Objekts durch die schwache Referenz in dieser Basisklasse und Aktienbesitz mit ihnen gespeichert sind, anstatt davon auszugehen, dass das Objekt nicht verwaltet .
Original:
When constructing from a raw pointer to an object of a type derived from std::enable_shared_from_this, the constructors of shared_ptr detect other owners of the object through the weak reference stored in that base class and share ownership with them, instead of assuming that the object is not managed.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Parameter

ptr -
werden. ein Zeiger auf ein Objekt zu verwalten
Original:
a pointer to an object to manage
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d -
ein deleter zu verwenden, um das Objekt zu zerstören
Original:
a deleter to use to destroy the object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
alloc -
eine Zuweisung für Zuweisungen von Daten für den internen Gebrauch verwenden
Original:
an allocator to use for allocations of data for internal use
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
r -
ein weiteres Smart-Pointer, das Eigentum zu teilen oder erwirbt das Eigentum aus
Original:
another smart pointer to share the ownership to or acquire the ownership from
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Ausnahmen

1)
noexcept specification:  
noexcept
  (seit C++11)
2)
std::bad_alloc bei Bedarf zusätzliche Speicher nicht erhalten werden konnten. Kann durch die Implementierung definiert Ausnahme für andere Fehler werfen. delete ptr wird aufgerufen, wenn eine Ausnahme auftritt .
Original:
std::bad_alloc if required additional memory could not be obtained. May throw implementation-defined exception for other errors. delete ptr is called if an exception occurs.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3-4)
std::bad_alloc bei Bedarf zusätzliche Speicher nicht erhalten werden konnten. Kann durch die Implementierung definiert Ausnahme für andere Fehler werfen. d(ptr) wird aufgerufen, wenn eine Ausnahme auftritt .
Original:
std::bad_alloc if required additional memory could not be obtained. May throw implementation-defined exception for other errors. d(ptr) is called if an exception occurs.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
noexcept specification:  
noexcept
  (seit C++11)
6-7)
std::bad_alloc bei Bedarf zusätzliche Speicher nicht erhalten werden konnten. Kann durch die Implementierung definiert Ausnahme für andere Fehler werfen. Wenn eine Ausnahme ausgelöst wird, wird d(ptr) ausgeführt .
Original:
std::bad_alloc if required additional memory could not be obtained. May throw implementation-defined exception for other errors. If an exception is thrown, d(ptr) is executed.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8-10)
noexcept specification:  
noexcept
  (seit C++11)
11)
std::bad_weak_ptr wenn r.expired == true. Der Konstruktor hat keine Wirkung in diesem Fall .
Original:
std::bad_weak_ptr if r.expired == true. The constructor has no effect in this case.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
12)
std::bad_alloc bei Bedarf zusätzliche Speicher nicht erhalten werden konnten. Kann durch die Implementierung definiert Ausnahme für andere Fehler werfen. Dieser Konstruktor hat keinen Effekt, wenn eine Ausnahme auftritt .
Original:
std::bad_alloc if required additional memory could not be obtained. May throw implementation-defined exception for other errors. This constructor has no effect if an exception occurs.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
13)
Wenn eine Ausnahme ausgelöst wird, hat der Konstruktor keine Auswirkungen .
Original:
If an exception is thrown, the constructor has no effects.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Beispiel

#include <memory>
#include <iostream>
 
struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
 
struct D { 
    void operator()(Foo* p) const {
        std::cout << "Call delete for Foo object...\n";
        delete p;
    }
};
 
int main()
{	
    // constructor with no managed object
    std::shared_ptr<Foo> sh1;
 
    // constructor with object
    std::shared_ptr<Foo> sh2(new Foo);
    std::shared_ptr<Foo> sh3(sh2);
    std::cout << sh2.use_count() << '\n';
    std::cout << sh3.use_count() << '\n';
 
    //constructor with object and deleter
    std::shared_ptr<Foo> sh4(new Foo, D());
}

Output:

Foo...
2
2
Foo...
Call delete for Foo object...
~Foo...
~Foo...

[Bearbeiten] Siehe auch

erzeugt einen shared_ptr, der ein neues Objekt verwaltet
(Funktions-Template) [edit]
erzeugt einen shared_ptr, der ein neues Objekt verwaltet, das mittels eines allocators erzeugt wird.
(Funktions-Template) [edit]