Freigeben über


<memory> -Funktionen

addressof

Ruft die echte Adresse eines Objekts ab.

template <class T>
T* addressof(
    T& value) noexcept;    // before C++17

template <class T>
constexpr T* addressof(
    T& value) noexcept;    // C++17

template <class T>
const T* addressof(
    const T&& value) = delete;   // C++17

Parameter

value
Das Objekt oder die Funktion, für das bzw. die die echte Adresse abgerufen wird.

Rückgabewert

Die tatsächliche Adresse des Objekts bzw. der Funktion, auf die value verweist, selbst wenn ein überladenes operator&()-Element vorhanden ist.

Hinweise

align

Passt den Speicher der angegebenen Größe an, die durch die angegebene Ausrichtungsspezifikation ausgerichtet ist, in die erste mögliche Adresse des angegebenen Speichers.

void* align(
    size_t alignment, // input
    size_t size,      // input
    void*& ptr,       // input/output
    size_t& space     // input/output
);

Parameter

alignment
Die auszuprobierende Ausrichtungsgrenze.

size
Die Größe in Bytes für den ausgerichteten Speicher.

ptr
Die Startadresse des verfügbaren zusammenhängenden Speicherpools, der verwendet werden soll. Dieser Parameter ist auch ein Ausgabeparameter und wird so festgelegt, dass die neue Startadresse enthalten ist, wenn die Ausrichtung erfolgreich ist. Wenn align() dieser Parameter nicht erfolgreich ist, wird dieser Parameter nicht geändert.

space
Der gesamte verfügbare Speicherplatz, den align() beim Erstellen des ausgerichteten Speichers verwendet. Dieser Parameter ist auch ein Ausgabeparameter und enthält den angepassten Speicherplatz, der im Speicherpuffer verblieben ist, nachdem der ausgerichtete Speicher und der zugeordnete Mehraufwand subtrahiert wurden.

Wenn align() dieser Parameter nicht erfolgreich ist, wird dieser Parameter nicht geändert.

Rückgabewert

Ein NULL Zeiger, wenn der angeforderte ausgerichtete Puffer nicht in den verfügbaren Platz passt; andernfalls der neue Wert von ptr.

Hinweise

Die geänderten Parameter ptr und space ermöglichen es Ihnen, align() im gleichen Puffer wiederholt aufzurufen, möglicherweise mit verschiedenen Werten für alignment und size . Im folgenden Codeausschnitt wird eine Verwendung von align() veranschaulicht:

#include <type_traits> // std::alignment_of()
#include <memory>
//...
char buffer[256]; // for simplicity
size_t alignment = std::alignment_of<int>::value;
void * ptr = buffer;
std::size_t space = sizeof(buffer); // Be sure this results in the true size of your buffer

while (std::align(alignment, sizeof(MyObj), ptr, space)) {
    // You now have storage the size of MyObj, starting at ptr, aligned on
    // int boundary. Use it here if you like, or save off the starting address
    // contained in ptr for later use.
    // ...
    // Last, move starting pointer and decrease available space before
    // the while loop restarts.
    ptr = reinterpret_cast<char*>(ptr) + sizeof(MyObj);
    space -= sizeof(MyObj);
}
// At this point, align() has returned a null pointer, signaling it is not
// possible to allow more aligned storage in this buffer.

allocate_shared

Erstellt einen shared_ptr auf Objekte, die einem angegebenen Typ mit einer angegebenen Zuweisung zugeordnet und dafür erstellt werden. Gibt shared_ptr zurück.

template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
    Allocator alloc,
    Args&&... args);

Parameter

alloc
Die Zuweisung wird zur Erstellung von Objekten verwendet.

args
Keine oder mehrere Argumente, die zu Objekten werden.

Hinweise

Die Funktion erstellt das Objekt shared_ptr<T>, ein Zeiger auf T(args...), wie von alloc zugewiesen und erstellt.

atomic_compare_exchange_strong

template<class T>
bool atomic_compare_exchange_strong(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w);

atomic_compare_exchange_weak

template<class T>
bool atomic_compare_exchange_weak(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w);

atomic_compare_exchange_strong_explicit

template<class T>
bool atomic_compare_exchange_strong_explicit(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w,
    memory_order success,
    memory_order failure);

atomic_compare_exchange_weak_explicit

template<class T>
bool atomic_compare_exchange_weak_explicit(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w,
    memory_order success,
    memory_order failure);

atomic_exchange

template<class T>
shared_ptr<T> atomic_exchange(
    shared_ptr<T>* u,
    shared_ptr<T> r);

atomic_exchange_explicit

template<class T>
shared_ptr<T> atomic_exchange_explicit(
    shared_ptr<T>* u,
    shared_ptr<T> r,
    memory_order mo);

atomic_is_lock_free

template<class T>
bool atomic_is_lock_free(
    const shared_ptr<T>* u);

atomic_load

template<class T>
shared_ptr<T> atomic_load(
    const shared_ptr<T>* u);

atomic_load_explicit

template<class T>
shared_ptr<T> atomic_load_explicit(
    const shared_ptr<T>* u,
    memory_order mo);

atomic_store

template<class T>
void atomic_store(
    shared_ptr<T>* u,
    shared_ptr<T> r);

atomic_store_explicit

template<class T>
void atomic_store_explicit(
    shared_ptr<T>* u,
    shared_ptr<T> r,
    memory_order mo);

const_pointer_cast

Konstantenumwandlung in shared_ptr.

template <class T, class Other>
shared_ptr<T> const_pointer_cast(
    const shared_ptr<Other>& sp) noexcept;

template <class T, class Other>
shared_ptr<T> const_pointer_cast(
    shared_ptr<Other>&& sp) noexcept;

Parameter

T
Der Typ, der vom zurückgegebenen gemeinsamen Zeiger (shared pointer) gesteuert wird.

Other
Der Typ, der vom Argument für den gemeinsamen Zeiger gesteuert wird.

sp
Das Argument für den gemeinsamen Zeiger.

Hinweise

Die Vorlagenfunktion gibt ein leeres shared_ptr Objekt zurück, wenn const_cast<T*>(sp.get()) ein Nullzeiger zurückgegeben wird. Andernfalls wird ein shared_ptr<T> Objekt zurückgegeben, das die Ressource besitzt, die im Besitz spist. Der Ausdruck const_cast<T*>(sp.get()) muss gültig sein.

Beispiel

// std__memory__const_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int);
    std::shared_ptr<const int> sp1 =
        std::const_pointer_cast<const int>(sp0);

    *sp0 = 3;
    std::cout << "sp1 == " << *sp1 << std::endl;

    return (0);
}
sp1 == 3

declare_no_pointers

Einem Garbage Collector wird mitgeteilt, dass die Zeichen im Speicherblock, der von einem Basisadressenzeiger und -blockgröße definiert wurde, keine nachweisbaren Zeiger enthalten.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parameter

ptr
Adresse des ersten Zeichens, das keinen nachweisbaren Zeiger mehr enthält.

size
Größe des Blocks, der bei ptr beginnt, dass keine nachweisbaren Zeiger enthält.

Hinweise

Die Funktion informiert jeden Garbage Collector, dass die Adressen im Bereich [ptr, ptr + size) keine nachverfolgbaren Zeiger mehr enthalten. (Alle Zeiger auf den zugewiesenen Speicher dürfen nur abgeleitet werden, wenn sie erreichbar sind.)

declare_reachable

Der Garbage Collection wird mitgeteilt, dass die angegebene Adresse von zugewiesenem Speicher erreichbar ist.

void declare_reachable(
    void* ptr);

Parameter

ptr
Ein Zeiger auf einen erreichbaren zugewiesenen gültigen Speicherbereich.

Hinweise

Wenn ptr die Funktion nicht NULL ist, informiert die Funktion über einen Garbage Collector, der ptr jetzt erreichbar ist, d. h., er verweist auf gültig zugewiesenen Speicher.

default_delete

Es werden Objekte gelöscht, die operator new zugeordnet sind. Kann mit unique_ptr verwendet werden.

struct default_delete
{
    constexpr default_delete() noexcept = default;

    template <class Other, class = typename enable_if<is_convertible<Other*, T*>::value, void>::type>>
    default_delete(const default_delete<Other>&) noexcept;

    void operator()(T* ptr) const noexcept;
};

Parameter

ptr
Zeiger auf das zu löschende Objekt.

Other
Die anderen Typen von Elementen im Array, die gelöscht werden sollen.

Hinweise

Die Klassenvorlage beschreibt einen Löschvorgang, der skalare Objekte löscht, die operator newzugeordnet sind , geeignet für die Verwendung mit Klassenvorlage unique_ptr. Außerdem ist die explizite Spezialisierung default_delete<T[]> vorhanden.

destroy_at

template <class T>
void destroy_at(
    T* location);

Wie in location->~T().

destroy

template <class ForwardIterator>
void destroy(
    ForwardIterator first,
    ForwardIterator last);

Identisch mit:

for (; first != last; ++first)
    destroy_at(addressof(*first));

destroy_n

template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
    ForwardIterator first,
    Size count);

Identisch mit:

for (; count > 0; (void)++first, --count)
    destroy_at(addressof(*first));
return first;

dynamic_pointer_cast

Dynamische Umwandlung in shared_ptr.

template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
    const shared_ptr<Other>& sp) noexcept;

template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
    shared_ptr<Other>&& sp) noexcept;

Parameter

T
Der Typ, der vom zurückgegebenen gemeinsamen Zeiger (shared pointer) gesteuert wird.

Other
Der Typ, der vom Argument für den gemeinsamen Zeiger gesteuert wird.

sp
Das Argument für den gemeinsamen Zeiger.

Hinweise

Die Vorlagenfunktion gibt ein leeres shared_ptr Objekt zurück, wenn dynamic_cast<T*>(sp.get()) ein Nullzeiger zurückgegeben wird. Andernfalls wird ein shared_ptr<T> Objekt zurückgegeben, das die Ressource besitzt, die im Besitz spist. Der Ausdruck dynamic_cast<T*>(sp.get()) muss gültig sein.

Beispiel

// std__memory__dynamic_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

struct base
{
    virtual ~base() {}
    int value;
};

struct derived
    : public base
{
};

int main()
{
    std::shared_ptr<base> sp0(new derived);
    std::shared_ptr<derived> sp1 =
        std::dynamic_pointer_cast<derived>(sp0);

    sp0->value = 3;
    std::cout << "sp1->value == " << sp1->value << std::endl;

    return (0);
}
sp1->value == 3

get_deleter

Abrufen des Löschvorgangs aus einem shared_ptr.

template <class Deleter, class T>
Deleter* get_deleter(
    const shared_ptr<T>& sp) noexcept;

Parameter

Deleter
Der Deleter-Typ.

T
Der vom freigegebenen Zeiger gesteuerte Typ.

sp
Der freigegebene Zeiger.

Hinweise

Die Vorlagenfunktion gibt einen Zeiger auf den Löschtyp Deleter zurück, der zum shared_ptr Objekt spgehört. Wenn sp kein Löscher vorhanden ist oder der Löschvorgang nicht vom Typ Deleterist, gibt die Funktion 0 zurück.

Beispiel

// std__memory__get_deleter.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

struct base
{
    int value;
};

struct deleter
{
    void operator()(base *pb)
    {
        delete pb;
    }
};

int main()
{
    std::shared_ptr<base> sp0(new base);

    sp0->value = 3;
    std::cout << "get_deleter(sp0) != 0 == " << std::boolalpha
        << (std::get_deleter<deleter>(sp0) != 0) << std::endl;

    std::shared_ptr<base> sp1(new base, deleter());

    sp0->value = 3;
    std::cout << "get_deleter(sp1) != 0 == " << std::boolalpha
        << (std::get_deleter<deleter>(sp1) != 0) << std::endl;

    return (0);
}
get_deleter(sp0) != 0 == false
get_deleter(sp1) != 0 == true

get_pointer_safety

Gibt den Typ der Zeigersicherheit zurück, der von einem Garbage Collector angenommen wird.

pointer_safety get_pointer_safety() noexcept;

Hinweise

Die Funktion gibt den Typ der Zeigersicherheit zurück, die von einem automatischen Garbage Collector angenommen wird.

get_temporary_buffer

Ordnet temporären Speicher für eine Abfolge von Elementen zu, die eine bestimmte Anzahl von Elementen nicht überschreiten.

template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
    ptrdiff_t count);

Parameter

count
Die maximale Anzahl der angeforderten Elemente, denen Speicher zugewiesen werden soll.

Rückgabewert

Ein pair, dessen erste Komponente ein Zeiger auf den zugewiesenen Speicher ist, und dessen zweite Komponente die Größe des Puffers angibt; sie gibt die maximale Zahl an Elementen an, die gespeichert werden kann.

Hinweise

Die Funktion fordert Speicher an; möglicherweise wird diese Anforderung aber zurückgewiesen. Wenn kein Puffer zugewiesen ist, gibt die Funktion „pair“ zurück; dabei ist die zweite Komponente entspricht null und die erste Komponente dem NULL-Zeiger.

Verwenden Sie diese Funktion nur für temporären Arbeitsspeicher.

Beispiel

// memory_get_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

using namespace std;

int main( )
{
    // Create an array of ints
    int intArray [] = { 10, 20, 30, 40, 100, 200, 300, 1000, 2000 };
    int count = sizeof ( intArray ) / sizeof ( int );
    cout << "The number of integers in the array is: "
        << count << "." << endl;

    pair<int *, ptrdiff_t> resultPair;
    resultPair = get_temporary_buffer<int>( count );

    cout << "The number of elements that the allocated memory\n"
        << "could store is given by: resultPair.second = "
        << resultPair.second << "." << endl;
}
The number of integers in the array is: 9.
The number of elements that the allocated memory
could store is given by: resultPair.second = 9.

make_shared

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 T, class... Args>
shared_ptr<T> make_shared(
    Args&&... args);

Parameter

args
Null oder mehr Konstruktorargumente. Die Funktion leitet auf Grundlage der bereitgestellten Argumente die erforderliche die Konstruktorüberladung ab.

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. Diese Funktion ist sowohl schneller als auch führt zu einer geringeren Speicherfragmentierung, und es besteht keine Möglichkeit einer Ausnahme für eine Zuordnung, aber nicht für die andere. 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.

Erwägen Sie die Verwendung make_unique , wenn Sie keinen freigegebenen Zugriff auf das Objekt benötigen. Verwenden Sie allocate_shared diese Funktion, wenn Sie einen benutzerdefinierten Zuweisungstyp für das Objekt angeben müssen. Sie können nicht verwenden make_shared , wenn ihr Objekt einen benutzerdefinierten Löschvorgang erfordert, da es keine Möglichkeit gibt, den Löscher 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:

Playing Ode to Joy by Beethoven, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
Playing Greensleeves by Unknown, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3

make_unique

Erstellt und gibt ein unique_ptr Objekt des angegebenen Typs zurück, das mithilfe der angegebenen Argumente erstellt wird.

// make_unique<T>
template <class T, class... Args>
unique_ptr<T> make_unique(Args&&... args);

// make_unique<T[]>
template <class T>
unique_ptr<T> make_unique(size_t size);

// make_unique<T[N]> disallowed
template <class T, class... Args>
/* unspecified */ make_unique(Args&&...) = delete;

Parameter

T
Der Typ des Objekts, auf das unique_ptr zeigt.

Args
Die von args angegebenen Typen der Konstruktorargumente.

args
Die an den Konstruktor des Objekts vom Typ T übergebenen Argumente.

elements
Ein Array von Elementen des Typs T.

size
Die Anzahl von Elementen, denen im neue Array ein Bereich zugeordnet werden soll.

Hinweise

Die erste Überladung wird für einzelne Objekte verwendet. Die zweite Überladung wird für Arrays aufgerufen. Die dritte Überladung verhindert, dass Sie eine Arraygröße im Typargument (make_unique<T[N]>) angeben. Diese Konstruktion wird vom aktuellen Standard nicht unterstützt. Wenn Sie make_unique verwenden, um unique_ptr in ein Array zu erstellen, müssen die Arrayelemente separat initialisiert werden. Anstatt diese Überladung zu verwenden, ist vielleicht eine bessere Wahl, eine std::vector.

Da make_unique sorgfältig für die Ausnahmesicherheit implementiert wird, wird empfohlen, make_unique zu verwenden, anstatt unique_ptr -Konstruktoren direkt aufzurufen.

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung von make_unique. Weitere Beispiele finden Sie unter Vorgehensweise: Erstellen und Verwenden von unique_ptr-Instanzen.

class Animal
{
private:
    std::wstring genus;
    std::wstring species;
    int age;
    double weight;
public:
    Animal(const wstring&, const wstring&, int, double){/*...*/ }
    Animal(){}
};

void MakeAnimals()
{
    // Use the Animal default constructor.
    unique_ptr<Animal> p1 = make_unique<Animal>();

    // Use the constructor that matches these arguments
    auto p2 = make_unique<Animal>(L"Felis", L"Catus", 12, 16.5);

    // Create a unique_ptr to an array of 5 Animals
    unique_ptr<Animal[]> p3 = make_unique<Animal[]>(5);

    // Initialize the elements
    p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1);
    p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08);

    // auto p4 = p2; //C2280

    vector<unique_ptr<Animal>> vec;
    // vec.push_back(p2); //C2280
    // vector<unique_ptr<Animal>> vec2 = vec; // C2280

    // OK. p2 no longer points to anything
    vec.push_back(std::move(p2)); 

    // unique_ptr overloads operator bool
    wcout << boolalpha << (p2 == false) << endl; // Prints "true"

    // OK but now you have two pointers to the same memory location
    Animal* pAnimal = p2.get();

    // OK. p2 no longer points to anything
    Animal* p5 = p2.release();
}

Wenn der Fehler "C2280" in Verbindung mit unique_ptr angezeigt wird, ist der Grund dafür fast sicherlich, der Versuch, den Kopierkonstruktor aufzurufen, der eine gelöschte Funktion ist.

owner_less

Ermöglicht Mischvergleiche, die auf Besitz basieren, freigegebener und schwacher Zeiger. Gibt true zurück, wenn der linke Parameter von der Memberfunktion owner_before vor den rechten Parameter gesetzt wurde.

template <class T>
    struct owner_less; // not defined

template <class T>
struct owner_less<shared_ptr<T>>
{
    bool operator()(
        const shared_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;

    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;

    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;
};

template <class T>
struct owner_less<weak_ptr<T>>
    bool operator()(
        const weak_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;

    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;

    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;
};

template<> struct owner_less<void>
{
    template<class T, class U>
    bool operator()(
        const shared_ptr<T>& left,
        const shared_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const weak_ptr<T>& left,
        const weak_ptr<U>& right) const noexcept;
};

Parameter

left
Ein freigegebener oder schwacher Zeiger.

right
Ein freigegebener oder schwacher Zeiger.

Hinweise

Die Klassenvorlagen definieren alle memberoperatoren als Rückgabe left.owner_before(right).

reinterpret_pointer_cast

Erstellt ein neues shared_ptr aus einem vorhandenen freigegebenen Zeiger mithilfe einer Umwandlung.

template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
    const shared_ptr<U>& ptr) noexcept;

template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
    shared_ptr<U>&& ptr) noexcept;

Parameter

ptr
Ein Verweis auf ein shared_ptr<U>.

Hinweise

Wenn ptr sie leer ist, ist das neue shared_ptr ebenfalls leer, andernfalls teilt es den Besitz mit ptr. Der neue freigegebene Zeiger ist das Ergebnis der Auswertung reinterpret_cast<Y*>(ptr.get()), wo Y ist typename std::shared_ptr<T>::element_type. Das Verhalten ist nicht definiert, wenn reinterpret_cast<T*>((U*)nullptr) es nicht wohlgeformt ist.

Die Vorlagenfunktion, die einen Lvalue-Verweis verwendet, ist neu in C++17. Die Vorlagenfunktion, die einen Rvalue-Verweis verwendet, ist neu in C++20.

return_temporary_buffer

Gibt den temporären Speicher frei, der mithilfe der get_temporary_buffer-Vorlagenfunktion zugeordnet wurde.

template <class T>
void return_temporary_buffer(
    T* buffer);

Parameter

buffer
Ein Zeiger auf dem freizugebenden Speicher.

Hinweise

Verwenden Sie diese Funktion nur für temporären Arbeitsspeicher.

Beispiel

// memory_ret_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

using namespace std;

int main( )
{
    // Create an array of ints
    int intArray [] = { 10, 20, 30, 40, 100, 200, 300 };
    int count = sizeof ( intArray ) / sizeof ( int );
    cout << "The number of integers in the array is: "
         << count << "." << endl;

    pair<int *, ptrdiff_t> resultPair;
    resultPair = get_temporary_buffer<int>( count );

    cout << "The number of elements that the allocated memory\n"
         << " could store is given by: resultPair.second = "
         << resultPair.second << "." << endl;

    int* tempBuffer = resultPair.first;

    // Deallocates memory allocated with get_temporary_buffer
    return_temporary_buffer( tempBuffer );
}
The number of integers in the array is: 7.
The number of elements that the allocated memory
could store is given by: resultPair.second = 7.

static_pointer_cast

Statische Umwandlung in shared_ptr.

template <class T, class Other>
shared_ptr<T> static_pointer_cast(
    const shared_ptr<Other>& sp) noexcept;

template <class T, class Other>
shared_ptr<T> static_pointer_cast(
    shared_ptr<Other>&& sp) noexcept;

Parameter

T
Der Typ, der vom zurückgegebenen gemeinsamen Zeiger (shared pointer) gesteuert wird.

Other
Der Typ, der vom Argument für den gemeinsamen Zeiger gesteuert wird.

sp
Das Argument für den gemeinsamen Zeiger.

Hinweise

Die Vorlagenfunktion gibt ein leeres shared_ptr Objekt zurück, wenn sp es sich um ein leeres shared_ptr Objekt handelt. Andernfalls wird ein shared_ptr<T> Objekt zurückgegeben, das die Ressource besitzt, die im Besitz spist. Der Ausdruck static_cast<T*>(sp.get()) muss gültig sein.

Beispiel

// std__memory__static_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

struct base
{
    int value;
};

struct derived
    : public base
{
};

int main()
{
    std::shared_ptr<base> sp0(new derived);
    std::shared_ptr<derived> sp1 =
        std::static_pointer_cast<derived>(sp0);

    sp0->value = 3;
    std::cout << "sp1->value == " << sp1->value << std::endl;

    return (0);
}
sp1->value == 3

swap

Tauschen Sie zwei shared_ptr, unique_ptroder weak_ptr Objekte aus.

template <class T>
void swap(
    shared_ptr<T>& left,
    shared_ptr<T>& right) noexcept;

template <class T, class Deleter>
void swap(
    unique_ptr<T, Deleter>& left,
    unique_ptr<T, Deleter>& right) noexcept;

template <class T>
void swap(
    weak_ptr<T>& left,
    weak_ptr<T>& right) noexcept;

Parameter

T
Der vom Argumentzeiger gesteuerte Typ.

Deleter
Der Löschvorgang des eindeutigen Zeigertyps.

left
Der linke Zeiger.

right
Der rechte Zeiger.

Hinweise

Die Vorlagenfunktionen rufen left.swap(right) auf.

Beispiel

// std__memory__swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::shared_ptr<int> sp2(new int(10));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    sp1.swap(sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;

    swap(sp1, sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << std::endl;

    std::weak_ptr<int> wp1(sp1);
    std::weak_ptr<int> wp2(sp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    wp1.swap(wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    swap(wp1, wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    return (0);
}
*sp1 == 5
*sp1 == 10
*sp1 == 5

*wp1 == 5
*wp1 == 10
*wp1 == 5

undeclare_no_pointers

Einem Garbage Collector wird mitgeteilt, dass die Zeichen im Speicherblock, der von einem Basisadressenzeiger und -blockgröße definiert wurde, jetzt möglicherweise nachweisbare Zeiger enthalten.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parameter

ptr
Ein Zeiger auf die Speicheradresse, die zuvor mit declare_no_pointersder Verwendung gekennzeichnet wurde.

size
Die Anzahl der Bytes im Speicherbereich. Dieser Wert muss der im declare_no_pointers Anruf verwendeten Nummer entsprechen.

Hinweise

Die Funktion informiert jeden Garbage Collector, dass der Adressbereich [ptr, ptr + size) jetzt spurbare Zeiger enthalten kann.

undeclare_reachable

Widerruft eine Deklaration der Reichweite für einen angegebenen Speicherort.

template <class T>
T *undeclare_reachable(
    T* ptr);

Parameter

ptr
Ein Zeiger auf die Speicheradresse, die zuvor mit declare_reachableder Verwendung gekennzeichnet wurde.

Hinweise

Ist ptr dies nicht nullptrder Fall, informiert die Funktion über einen Garbage Collector, der ptr nicht mehr erreichbar ist. Es gibt einen sicher abgeleiteten Zeiger zurück, der gleich ist ptr.

uninitialized_copy

Es werden Objekte aus einem angegebenen Quellbereich in einen nicht initialisierten Zielbereich kopiert.

template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
    InputIterator first,
    InputIterator last,
    ForwardIterator dest);

template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
    ExecutionPolicy&& policy,
    InputIterator first,
    InputIterator last,
    ForwardIterator dest);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Eingabeiterator, der das erste Element im Quellbereich adressiert.

last
Ein Eingabeiterator, der das letzte Element im Quellbereich adressiert.

dest
Ein Forward-Iterator, der das erste Element im Zielbereich adressiert.

Rückgabewert

Ein Weiterleitungs-Iterator, der die erste Position außerhalb des Zielbereichs adressiert, es sei denn, der Quellbereich war leer.

Hinweise

Dieser Algorithmus ermöglicht die Entkopplung der Speicherbelegung von der Objekterstellung.

Die Vorlagenfunktion führt Folgendes aus:

while (first != last)
{
    new (static_cast<void*>(&* dest++))
        typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;

es sei denn, der Code löst eine Ausnahme aus. In diesem Fall sind alle erstellten Objekte zerstört und die Ausnahme wird erneut ausgelöst.

Die Überladung mit einer Ausführungsrichtlinie ist neu in C++17.

Beispiel

// memory_uninit_copy.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>

using namespace std;

class Integer
{
public:
    Integer(int x) : value(x) {}
    int get() { return value; }
private:
    int value;
};

int main()
{
    int Array[] = { 10, 20, 30, 40 };
    const int N = sizeof(Array) / sizeof(int);

    cout << "The initialized Array contains " << N << " elements: ";
    for (int i = 0; i < N; i++)
    {
        cout << " " << Array[i];
    }
    cout << endl;

    Integer* ArrayPtr = (Integer*)malloc(N * sizeof(int));
    Integer* LArrayPtr = uninitialized_copy(
        Array, Array + N, ArrayPtr);  // C4996

    cout << "Address of position after the last element in the array is: "
        << &Array[0] + N << endl;
    cout << "The iterator returned by uninitialized_copy addresses: "
        << (void*)LArrayPtr << endl;
    cout << "The address just beyond the last copied element is: "
        << (void*)(ArrayPtr + N) << endl;

    if ((&Array[0] + N) == (void*)LArrayPtr)
        cout << "The return value is an iterator "
        << "pointing just beyond the original array." << endl;
    else
        cout << "The return value is an iterator "
        << "not pointing just beyond the original array." << endl;

    if ((void*)LArrayPtr == (void*)(ArrayPtr + N))
        cout << "The return value is an iterator "
        << "pointing just beyond the copied array." << endl;
    else
        cout << "The return value is an iterator "
        << "not pointing just beyond the copied array." << endl;

    free(ArrayPtr);

    cout << "Note that the exact addresses returned will vary\n"
        << "with the memory allocation in individual computers."
        << endl;
}

uninitialized_copy_n

Eine Kopie einer angegebenen Anzahl von Elementen aus einem Eingabeiterator wird erstellt. Die Kopien werden in einen Forward-Iterator abgelegt.

template <class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
    InputIterator first,
    Size count,
    ForwardIterator dest);

template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
    ExecutionPolicy&& policy,
    InputIterator first,
    Size count,
    ForwardIterator dest);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Eingabeiterator, der auf das zu kopierende Objekt verweist.

count
Ein Ganzzahltyp mit oder ohne Vorzeichen, der die Anzahl von Kopiervorgängen für das Objekt angibt.

dest
Ein Forward-Iterator, der auf den Speicherort der neuen Kopien verweist.

Rückgabewert

Ein Forward-Iterator, der die erste Position nach dem Ziel adressiert. Wenn der Quellbereich leer war, werden die Iteratoradressen adressieren first.

Hinweise

Die Vorlagenfunktion führt effektiv den folgenden Code aus:

    for (; 0 < count; --count)
        new (static_cast<void*>(&* dest++))
            typename iterator_traits<InputIterator>::value_type(*first++);
    return dest;

es sei denn, der Code löst eine Ausnahme aus. In diesem Fall sind alle erstellten Objekte zerstört und die Ausnahme wird erneut ausgelöst.

Die Überladung mit einer Ausführungsrichtlinie ist neu in C++17.

uninitialized_default_construct

Standardmäßig werden Objekte der Iteratoren value_type im angegebenen Bereich erstellt.

template <class ForwardIterator>
void uninitialized_default_construct(
    ForwardIterator first,
    ForwardIterator last);

template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_default_construct(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    ForwardIterator last);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Iterator, der das erste zu konstruierende Element im Bereich adressiert.

last
Ein Iterator, der eins über das letzte Element im Bereich adressiert, das erstellt werden soll.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; first != last; ++first)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type;

Wenn eine Ausnahme ausgelöst wird, werden zuvor erstellte Objekte in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Diese Funktionen sind neu in C++17.

uninitialized_default_construct_n

Der Standardwert erstellt eine angegebene Anzahl von Objekten des Iterators value_type, beginnend an der angegebenen Position.

template <class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
    ForwardIterator first,
    Size count);

template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    Size count);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Iterator, der das erste Element im Zielbereich adressiert, das erstellt werden soll.

count
Die Anzahl der Zu erstellenden Elemente im Zielbereich.

Rückgabewert

Ein Weiterleitungs-Iterator, der die erste Position außerhalb des Zielbereichs adressiert, es sei denn, der Quellbereich war leer.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; count>0; (void)++first, --count)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type;
return first;

Wenn eine Ausnahme ausgelöst wird, werden zuvor erstellte Objekte in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Diese Funktionen sind neu in C++17.

uninitialized_fill

Objekte eines angegebenen Werts werden in einen nicht initialisierten Zielbereich kopiert.

template <class ForwardIterator, class T>
void uninitialized_fill(
    ForwardIterator first,
    ForwardIterator last,
    const T& value);

template <class ExecutionPolicy, class ForwardIterator, class T>
void uninitialized_fill(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    ForwardIterator last,
    const T& value);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Weiterleitungs-Iterator, der das erste Element im Zielbereich adressiert, um die Initialisierung zu initialisieren.

last
Ein Weiterleitungs-Iterator, der das letzte Element im Zielbereich adressiert, um die Initialisierung zu initialisieren.

value
Der Wert, der zum Initialisieren des Zielbereichs verwendet wird.

Hinweise

Dieser Algorithmus ermöglicht die Entkopplung der Speicherbelegung von der Objekterstellung.

Die Vorlagenfunktion führt Folgendes aus:

while (first != last)
    new (static_cast<void*>(&* first ++))
        typename iterator_traits<ForwardIterator>::value_type (value);

es sei denn, der Code löst eine Ausnahme aus. In diesem Fall sind alle erstellten Objekte zerstört und die Ausnahme wird erneut ausgelöst.

Die Überladung mit einer Ausführungsrichtlinie ist neu in C++17.

Beispiel

// memory_uninit_fill.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

using namespace std;

class Integer
{
public:
    // No default constructor
    Integer( int x ) : value( x ) {}
    int get() { return value; }
private:
    int value;
};

int main()
{
    const int N = 10;
    Integer value ( 25 );
    Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
    uninitialized_fill( Array, Array + N, value );
    cout << "The initialized Array contains: ";
    for ( int i = 0; i < N; i++ )
        {
            cout << Array[ i ].get() << " ";
        }
    cout << endl;
}
The initialized Array contains: 25 25 25 25 25 25 25 25 25 25

uninitialized_fill_n

Kopiert Objekte eines angegebenen Werts in die angegebene Anzahl von Elementen eines nicht initialisierten Zielbereichs.

template <class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
    ForwardIterator first,
    Size count,
    const T& value);

template <class ExecutionPolicy, class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    Size count,
    const T& value);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Weiterleitungs-Iterator, der das erste Element im Zielbereich adressiert, um die Initialisierung zu initialisieren.

count
Die Anzahl der zu initialisierenden Elemente.

value
Der Wert, der zum Initialisieren des Zielbereichs verwendet werden soll.

Hinweise

Dieser Algorithmus ermöglicht die Entkopplung der Speicherbelegung von der Objekterstellung.

Die Vorlagenfunktion führt Folgendes aus:

while (0 < count--)
    new (static_cast<void*>(&* first++))
        typename iterator_traits<ForwardIterator>::value_type(value);
return first;

es sei denn, der Code löst eine Ausnahme aus. In diesem Fall sind alle erstellten Objekte zerstört und die Ausnahme wird erneut ausgelöst.

Die Überladung mit einer Ausführungsrichtlinie ist neu in C++17.

Beispiel

// memory_uninit_fill_n.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>

using namespace std;

class Integer
{
public:
    // No default constructor
    Integer( int x ) : value( x ) {}
    int get() { return value; }
private:
    int value;
};

int main()
{
    const int N = 10;
    Integer value( 60 );
    Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
    uninitialized_fill_n( Array, N, value );  // C4996
    cout << "The uninitialized Array contains: ";
    for ( int i = 0; i < N; i++ )
        cout << Array[ i ].get() <<  " ";
}

uninitialized_move

Verschiebt Elemente aus einem Quellbereich in einen nicht initialisierten Zielspeicherbereich.

template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
    InputIterator first,
    InputIterator last,
    ForwardIterator dest);

template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
    ExecutionPolicy&& policy,
    InputIterator first,
    InputIterator last,
    ForwardIterator dest);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Quellbereich adressiert, das verschoben werden soll.

last
Ein Eingabe-Iterator, der eins über das letzte Element im Quellbereich adressiert, um zu verschieben.

dest
Der Anfang des Zielbereichs.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; first != last; (void)++dest, ++first)
    ::new (static_cast<void*>(addressof(*dest)))
        typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;

Wenn eine Ausnahme ausgelöst wird, verbleiben einige Objekte im Quellbereich möglicherweise in einem gültigen, aber nicht angegebenen Zustand. Zuvor konstruierte Objekte werden in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Diese Funktionen sind neu in C++17.

uninitialized_move_n

Verschiebt eine angegebene Anzahl von Elementen aus einem Quellbereich in einen nicht initialisierten Zielspeicherbereich.

template <class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
    InputIterator first,
    Size count,
    ForwardIterator dest);

template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
    ExecutionPolicy&& policy,
    InputIterator first,
    Size count,
    ForwardIterator dest);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Quellbereich adressiert, das verschoben werden soll.

count
Die Anzahl der Elemente im Quellbereich, die verschoben werden sollen.

dest
Der Anfang des Zielbereichs.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; count > 0; ++dest, (void) ++first, --count)
    ::new (static_cast<void*>(addressof(*dest)))
        typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return {first, dest};

Wenn eine Ausnahme ausgelöst wird, verbleiben einige Objekte im Quellbereich möglicherweise in einem gültigen, aber nicht angegebenen Zustand. Zuvor konstruierte Objekte werden in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Diese Funktionen sind neu in C++17.

uninitialized_value_construct

Erstellt Objekte der Iteratoren value_type anhand der Wertinitialisierung im angegebenen Bereich.

template <class ForwardIterator>
void uninitialized_value_construct(
    ForwardIterator first,
    ForwardIterator last);

template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_value_construct(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    ForwardIterator last);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Iterator, der das erste Element im Bereich angibt, um ein Wertkonstrukt zu erstellen.

last
Ein Iterator, der eins über das letzte Element im Bereich zum Wertkonstrukt adressiert.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; first != last; ++first)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type();

Wenn eine Ausnahme ausgelöst wird, werden zuvor erstellte Objekte in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Wenn ein Speicherzuweisungsfehler auftritt, wird eine std::bad_alloc Ausnahme ausgelöst.

Diese Funktionen sind neu in C++17.

uninitialized_value_construct_n

Erstellt eine angegebene Anzahl von Objekten des Iterators value_type anhand der Wertinitialisierung, beginnend an der angegebenen Position.

template <class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
    ForwardIterator first,
    Size count);

template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
    ExecutionPolicy&& policy,
    ForwardIterator first,
    Size count);

Parameter

policy
Die zu verwendende Ausführungsrichtlinie.

first
Ein Iterator, der das erste Element im Zielbereich adressiert, das erstellt werden soll.

count
Die Anzahl der Zu erstellenden Elemente im Zielbereich.

Hinweise

Die Version ohne Ausführungsrichtlinie ist effektiv identisch mit:

for (; count > 0; (void)++first, --count)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type();
return first;

Wenn eine Ausnahme ausgelöst wird, werden zuvor erstellte Objekte in nicht angegebener Reihenfolge zerstört.

Die Version mit einer Ausführungsrichtlinie hat dasselbe Ergebnis, wird jedoch gemäß der angegebenen Ausgeführt policy.

Wenn ein Speicherzuweisungsfehler auftritt, wird eine std::bad_alloc Ausnahme ausgelöst.

Diese Funktionen sind neu in C++17.

uses_allocator_v

Eine Hilfsvariablenvorlage für den Zugriff auf den Wert der uses_allocator Vorlage.

template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;

Siehe auch

<memory>