<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;