<memory> funzioni
addressof
Ottiene l'indirizzo true di un oggetto.
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
Parametri
value
Oggetto o funzione per cui ottenere l'indirizzo true.
Valore restituito
Indirizzo effettivo dell'oggetto o della funzione a cui fa riferimento value, anche se esiste un operator&() sottoposto a overload.
Osservazioni:
align
Adatta l'archiviazione delle dimensioni specificate, allineate in base alla specifica di allineamento specificata, nel primo indirizzo possibile della risorsa di archiviazione specificata.
void* align(
size_t alignment, // input
size_t size, // input
void*& ptr, // input/output
size_t& space // input/output
);
Parametri
alignment
Limite di allineamento da tentare.
size
Dimensioni in byte dell'archivio allineato.
ptr
Indirizzo iniziale del pool di archiviazione contiguo disponibile da utilizzare. Questo parametro è anche un parametro di output e viene impostato per contenere il nuovo indirizzo iniziale se l'allineamento ha esito positivo. In caso align() di esito negativo, questo parametro non viene modificato.
space
Spazio totale disponibile per align() da utilizzare per la creazione di un'archivio allineato. Questo parametro è anche un parametro di output e contiene lo spazio modificato disponibile nel buffer di archiviazione dopo la sottrazione dell'archivio allineato e dell'eventuale sovraccarico associato.
In caso align() di esito negativo, questo parametro non viene modificato.
Valore restituito
Puntatore NULL se il buffer allineato richiesto non rientra nello spazio disponibile; in caso contrario, il nuovo valore di ptr.
Osservazioni:
I parametri ptr e space modificati consentono di chiamare più volte align() nello stesso buffer, possibilmente con valori diversi per alignment e size. Nel frammento di codice riportato di seguito viene illustrato un utilizzo di align().
#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
Crea un shared_ptr agli oggetti allocati e costruiti per un tipo specificato mediante un allocatore specificato. Restituisce shared_ptr.
template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
Allocator alloc,
Args&&... args);
Parametri
alloc
Allocatore utilizzato per creare oggetti.
args
Zero o più argomenti che diventano gli oggetti.
Osservazioni:
La funzione crea l'oggetto shared_ptr<T>, un puntatore a T(args...) come allocato e costruito da alloc.
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
Esegue il cast della costante a 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;
Parametri
T
Tipo controllato dal puntatore condiviso restituito.
Other
Tipo controllato dal puntatore di tipo argument condiviso.
sp
Puntatore di tipo argument condiviso.
Osservazioni:
La funzione modello restituisce un oggetto vuoto shared_ptr se const_cast<T*>(sp.get()) restituisce un puntatore Null; in caso contrario, restituisce un shared_ptr<T> oggetto proprietario della risorsa di proprietà di sp. L'espressione const_cast<T*>(sp.get()) deve essere valida.
Esempio
// 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
Informa un Garbage Collector che i caratteri del blocco di memoria definito da un puntatore all'indirizzo di base e la dimensione del blocco non contengono puntatori tracciabili.
void declare_no_pointers(
char* ptr,
size_t size);
Parametri
ptr
Indirizzo del primo carattere che non contiene più puntatori tracciabili.
size
Dimensione del blocco che inizia in corrispondenza di ptr e non contiene puntatori tracciabili.
Osservazioni:
La funzione informa qualsiasi Garbage Collector che gli indirizzi nell'intervallo [ptr, ptr + size) non contengono più puntatori tracciabili. Qualsiasi puntatore all'archiviazione allocata non deve essere dereferenziato a meno che non sia raggiungibile.
declare_reachable
Informa un Garbage Collection che l'indirizzo indicato si riferisce all'archiviazione allocata ed è raggiungibile.
void declare_reachable(
void* ptr);
Parametri
ptr
Puntatore a un'area di archiviazione raggiungibile, allocata e valida.
Osservazioni:
Se ptr non è Null, la funzione informa qualsiasi Garbage Collector ptr raggiungibile, ovvero punta all'archiviazione allocata valida.
default_delete
Elimina gli oggetti allocati con operator new. Adatto per l'utilizzo con unique_ptr.
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;
};
Parametri
ptr
Il puntatore dell'oggetto da eliminare.
Other
Il tipo di elementi nella matrice da eliminare.
Osservazioni:
Il modello di classe descrive un deleter che elimina gli oggetti scalari allocati con operator new, adatto per l'uso con il modello di unique_ptrclasse . Include inoltre la specializzazione esplicita default_delete<T[]>.
destroy_at
template <class T>
void destroy_at(
T* location);
Uguale a location->~T().
destroy
template <class ForwardIterator>
void destroy(
ForwardIterator first,
ForwardIterator last);
Uguale a:
for (; first != last; ++first)
destroy_at(addressof(*first));
destroy_n
template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
ForwardIterator first,
Size count);
Uguale a:
for (; count > 0; (void)++first, --count)
destroy_at(addressof(*first));
return first;
dynamic_pointer_cast
Esegue il cast dinamico a 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;
Parametri
T
Tipo controllato dal puntatore condiviso restituito.
Other
Tipo controllato dal puntatore di tipo argument condiviso.
sp
Puntatore di tipo argument condiviso.
Osservazioni:
La funzione modello restituisce un oggetto vuoto shared_ptr se dynamic_cast<T*>(sp.get()) restituisce un puntatore Null; in caso contrario, restituisce un shared_ptr<T> oggetto proprietario della risorsa di proprietà di sp. L'espressione dynamic_cast<T*>(sp.get()) deve essere valida.
Esempio
// 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
Ottenere l'deleter da un oggetto shared_ptr.
template <class Deleter, class T>
Deleter* get_deleter(
const shared_ptr<T>& sp) noexcept;
Parametri
Deleter
Tipo del metodo Deleter.
T
Tipo controllato dal puntatore condiviso.
sp
Puntatore condiviso.
Osservazioni:
La funzione modello restituisce un puntatore all'deleter di tipo Deleter appartenente all'oggetto shared_ptr sp. Se sp non dispone di deleter o se il relativo deleter non è di tipo Deleter, la funzione restituisce 0.
Esempio
// 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
Restituisce il tipo di sicurezza dei puntatori utilizzata dal Garbage Collector.
pointer_safety get_pointer_safety() noexcept;
Osservazioni:
La funzione restituisce il tipo di sicurezza del puntatore assunto da qualsiasi Garbage Collector automatico.
get_temporary_buffer
Alloca l'archiviazione temporanea per una sequenza di elementi che non supera un numero specificato di elementi.
template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
ptrdiff_t count);
Parametri
count
Numero massimo di elementi richiesti per cui deve essere allocata la memoria.
Valore restituito
Oggetto pair il cui primo componente è un puntatore alla memoria allocata e il secondo componente fornisce la dimensione del buffer, per indicare il numero massimo di elementi che è possibile archiviare.
Osservazioni:
La funzione esegue una richiesta di memoria ed è possibile che tale richiesta non abbia esito positivo. Se non viene allocato alcun buffer, la funzione restituisce una coppia in cui il secondo componente è uguale a zero e il primo è uguale al puntatore null.
Usare questa funzione solo per la memoria temporanea.
Esempio
// 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
Crea e restituisce un oggetto shared_ptr che punta all'oggetto allocato costruito da zero o più argomenti usando l'allocatore predefinito. Alloca e costruisce un oggetto del tipo specifico e shared_ptr per gestire la proprietà condivisa dell'oggetto e restituisce shared_ptr.
template <class T, class... Args>
shared_ptr<T> make_shared(
Args&&... args);
Parametri
args
Zero o più argomenti del costruttore. La funzione deduce di quale costruttore eseguire l'overload per richiamare il costruttore in base agli argomenti forniti.
Osservazioni:
Usare make_shared come metodo semplice ed efficace per creare un oggetto e shared_ptr per gestire contemporaneamente l'accesso condiviso all'oggetto. Semanticamente, queste due istruzioni sono equivalenti:
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
Tuttavia, la prima istruzione crea due allocazioni e, se l'allocazione di shared_ptr non riesce dopo la corretta allocazione dell'oggetto Example, l'oggetto senza nome Example viene perso. L'istruzione che usa make_shared è più semplice perché comprende una sola chiamata di funzione. È più efficiente perché la libreria può eseguire una singola allocazione per l'oggetto e il puntatore intelligente. Questa funzione è sia più veloce che porta a una minore frammentazione della memoria e non è possibile che si verifichi un'eccezione in un'allocazione, ma non nell'altra. Le prestazioni sono migliorate grazie a un posizionamento più preciso del codice che fa riferimento all'oggetto e aggiorna i conteggi dei riferimenti nel puntatore intelligente.
È consigliabile usare make_unique se non è necessario l'accesso condiviso all'oggetto . Utilizzare allocate_shared se è necessario specificare un allocatore personalizzato per l'oggetto . Non è possibile usare make_shared se l'oggetto richiede un deleter personalizzato, perché non è possibile passare l'deleter come argomento.
Nell'esempio seguente viene mostrato come creare puntatori condivisi a un tipo richiamando overload specifici del costruttore.
Esempio
// 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();
}
L'esempio produce il seguente output:
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
Crea e restituisce un oggetto unique_ptr a un oggetto del tipo specificato, costruito utilizzando gli argomenti specificati.
// 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;
Parametri
T
Tipo dell'oggetto a cui punta unique_ptr.
Args
Tipi di argomenti del costruttore specificati da args.
args
Argomenti da passare al costruttore dell'oggetto di tipo T.
elements
Matrice di elementi di tipo T.
size
Numero di elementi per allocare spazio per la nuova matrice.
Osservazioni:
Il primo overload viene usato per singoli oggetti. Il secondo overload viene richiamato per le matrici. Il terzo overload impedisce di specificare una dimensione della matrice nell'argomento di tipo (make_unique<T[N]>); questa costruzione non è supportata dallo standard corrente. Quando si usa make_unique per creare un unique_ptr a una matrice, è necessario inizializzare gli elementi della matrice separatamente. Anziché usare questo overload, forse una scelta migliore consiste nell'usare un oggetto std::vector.
Poiché make_unique viene implementato con cautela per la sicurezza dell'eccezione, si consiglia di utilizzare make_unique anziché chiamare direttamente i costruttori unique_ptr.
Esempio
Nell'esempio riportato di seguito viene illustrato come usare make_unique. Per altri esempi, vedere Procedura: creare e utilizzare istanze unique_ptr.
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();
}
Quando viene visualizzato l'errore C2280 in relazione a unique_ptr, è quasi certo che sia dovuto al tentativo di richiamare il costruttore di copia, che è una funzione eliminata.
owner_less
Consente confronti misti basati sulla proprietà dei puntatori condivisi e deboli. Restituisce true se la funzione membro owner_before ordina i parametri ponendo quello di sinistra prima di quello di destra.
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;
};
Parametri
left
Puntatore debole non valido.
right
Puntatore debole non valido.
Osservazioni:
I modelli di classe definiscono tutti i relativi operatori membro come restituzione di left.owner_before(right).
reinterpret_pointer_cast
Crea un nuovo shared_ptr oggetto da un puntatore condiviso esistente usando un cast.
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;
Parametri
ptr
Riferimento a un oggetto shared_ptr<U>.
Osservazioni:
Se ptr è vuoto, il nuovo shared_ptr è vuoto, altrimenti condivide la proprietà con ptr. Il nuovo puntatore reinterpret_cast<Y*>(ptr.get())condiviso è il risultato della valutazione di , dove Y è typename std::shared_ptr<T>::element_type. Il comportamento non è definito se reinterpret_cast<T*>((U*)nullptr) non è ben formato.
La funzione modello che accetta un riferimento lvalue è nuova in C++17. La funzione modello che accetta un riferimento rvalue è nuova in C++20.
return_temporary_buffer
Dealloca la memoria temporanea allocata tramite la funzione di modello get_temporary_buffer.
template <class T>
void return_temporary_buffer(
T* buffer);
Parametri
buffer
Puntatore alla memoria da deallocare.
Osservazioni:
Usare questa funzione solo per la memoria temporanea.
Esempio
// 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
Esegue un cast statico a 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;
Parametri
T
Tipo controllato dal puntatore condiviso restituito.
Other
Tipo controllato dal puntatore di tipo argument condiviso.
sp
Puntatore di tipo argument condiviso.
Osservazioni:
La funzione modello restituisce un oggetto vuoto shared_ptr se sp è un oggetto vuoto shared_ptr ; in caso contrario, restituisce un shared_ptr<T> oggetto proprietario della risorsa di proprietà di sp. L'espressione static_cast<T*>(sp.get()) deve essere valida.
Esempio
// 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
Scambiare due shared_ptroggetti , unique_ptro weak_ptr .
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;
Parametri
T
Tipo controllato dal puntatore argomento.
Deleter
Deleter del tipo di puntatore univoco.
left
Puntatore sinistro.
right
Puntatore destro.
Osservazioni:
Le funzioni modello chiamano left.swap(right).
Esempio
// 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
Informa un Garbage Collector che i caratteri del blocco di memoria definito da un puntatore all'indirizzo di base e la dimensione del blocco possono contenere puntatori tracciabili.
void undeclare_no_pointers(
char* ptr,
size_t size);
Parametri
ptr
Puntatore all'indirizzo di memoria contrassegnato in precedenza tramite declare_no_pointers.
size
Numero di byte nell'intervallo di memoria. Questo valore deve essere uguale al numero utilizzato nella declare_no_pointers chiamata.
Osservazioni:
La funzione informa qualsiasi Garbage Collector che l'intervallo di indirizzi può ora contenere puntatori [ptr, ptr + size) tracciabili.
undeclare_reachable
Revoca una dichiarazione di raggiungibilità per una posizione di memoria specificata.
template <class T>
T *undeclare_reachable(
T* ptr);
Parametri
ptr
Puntatore all'indirizzo di memoria contrassegnato in precedenza tramite declare_reachable.
Osservazioni:
Se ptr non nullptrè , la funzione informa qualsiasi Garbage Collector che ptr non è più raggiungibile. Restituisce un puntatore derivato in modo sicuro che confronta uguale a ptr.
uninitialized_copy
Copia gli oggetti da un intervallo di origine specificato in un intervallo di destinazione non inizializzato.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore di input che punta al primo elemento dell'intervallo di origine.
last
Iteratore di input che punta all'ultimo elemento dell'intervallo di origine.
dest
Iteratore in avanti che punta al primo elemento dell'intervallo di destinazione.
Valore restituito
Iteratore in avanti che punta alla prima posizione oltre l'intervallo di destinazione, a meno che l'intervallo di origine non sia vuoto.
Osservazioni:
Questo algoritmo consente la separazione dell'allocazione della memoria dalla costruzione di un oggetto.
La funzione di modello consente di gestire in modo efficace quanto segue:
while (first != last)
{
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;
a meno che il codice non generi un'eccezione. In tal caso, tutti gli oggetti creati vengono eliminati definitivamente e l'eccezione viene generata nuovamente.
L'overload con un criterio di esecuzione è una novità di C++17.
Esempio
// 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
Crea una copia di un numero specificato di elementi da un iteratore di input. Le copie vengono inserite in un iteratore in avanti.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore di input che fa riferimento all'oggetto da copiare.
count
Tipo Signed Integer o Unsigned Integer che specifica il numero di volte in cui copiare l'oggetto.
dest
Iteratore in avanti che fa riferimento al punto in cui vengono inserite le nuove copie.
Valore restituito
Iteratore in avanti che punta alla prima posizione oltre la destinazione. Se l'intervallo di origine è vuoto, l'iteratore punta firsta .
Osservazioni:
La funzione modello esegue in modo efficace il codice seguente:
for (; 0 < count; --count)
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
return dest;
a meno che il codice non generi un'eccezione. In tal caso, tutti gli oggetti creati vengono eliminati definitivamente e l'eccezione viene generata nuovamente.
L'overload con un criterio di esecuzione è una novità di C++17.
uninitialized_default_construct
Il valore predefinito costruisce oggetti degli iteratori nell'intervallo value_type specificato.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore che punta al primo elemento dell'intervallo da costruire.
last
Iteratore che punta a un altro oltre l'ultimo elemento dell'intervallo da costruire.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
Se viene generata un'eccezione, gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Queste funzioni sono nuove in C++17.
uninitialized_default_construct_n
L'impostazione predefinita costruisce un numero specificato di oggetti dell'iteratore value_type, a partire dalla posizione specificata.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore che punta al primo elemento dell'intervallo di destinazione da costruire.
count
Conteggio degli elementi nell'intervallo di destinazione da costruire.
Valore restituito
Iteratore in avanti che punta alla prima posizione oltre l'intervallo di destinazione, a meno che l'intervallo di origine non sia vuoto.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
for (; count>0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
return first;
Se viene generata un'eccezione, gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Queste funzioni sono nuove in C++17.
uninitialized_fill
Copia gli oggetti di un valore specificato in un intervallo di destinazione non inizializzato.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore in avanti che punta al primo elemento dell'intervallo di destinazione da inizializzare.
last
Iteratore in avanti che punta all'ultimo elemento dell'intervallo di destinazione da inizializzare.
value
Valore da utilizzare per inizializzare l'intervallo di destinazione.
Osservazioni:
Questo algoritmo consente la separazione dell'allocazione della memoria dalla costruzione di un oggetto.
La funzione di modello consente di gestire in modo efficace quanto segue:
while (first != last)
new (static_cast<void*>(&* first ++))
typename iterator_traits<ForwardIterator>::value_type (value);
a meno che il codice non generi un'eccezione. In tal caso, tutti gli oggetti creati vengono eliminati definitivamente e l'eccezione viene generata nuovamente.
L'overload con un criterio di esecuzione è una novità di C++17.
Esempio
// 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
Copia gli oggetti di un valore specificato nel numero specificato di elementi di un intervallo di destinazione non inizializzato.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore in avanti che punta al primo elemento dell'intervallo di destinazione da inizializzare.
count
Numero di elementi da inizializzare.
value
Valore da utilizzare per inizializzare l'intervallo di destinazione.
Osservazioni:
Questo algoritmo consente la separazione dell'allocazione della memoria dalla costruzione di un oggetto.
La funzione di modello consente di gestire in modo efficace quanto segue:
while (0 < count--)
new (static_cast<void*>(&* first++))
typename iterator_traits<ForwardIterator>::value_type(value);
return first;
a meno che il codice non generi un'eccezione. In tal caso, tutti gli oggetti creati vengono eliminati definitivamente e l'eccezione viene generata nuovamente.
L'overload con un criterio di esecuzione è una novità di C++17.
Esempio
// 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
Sposta gli elementi da un intervallo di origine a un'area di memoria di destinazione non inizializzata.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore di input che punta al primo elemento dell'intervallo di origine da spostare.
last
Iteratore di input che punta a un altro oltre l'ultimo elemento dell'intervallo di origine da spostare.
dest
Inizio dell'intervallo di destinazione.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
for (; first != last; (void)++dest, ++first)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;
Se viene generata un'eccezione, alcuni oggetti nell'intervallo di origine potrebbero essere lasciati in uno stato valido ma non specificato. Gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Queste funzioni sono nuove in C++17.
uninitialized_move_n
Sposta un numero specificato di elementi da un intervallo di origine a un'area di memoria di destinazione non inizializzata.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore di input che punta al primo elemento dell'intervallo di origine da spostare.
count
Numero di elementi nell'intervallo di origine da spostare.
dest
Inizio dell'intervallo di destinazione.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
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};
Se viene generata un'eccezione, alcuni oggetti nell'intervallo di origine potrebbero essere lasciati in uno stato valido ma non specificato. Gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Queste funzioni sono nuove in C++17.
uninitialized_value_construct
Costruisce oggetti degli iteratori' value_type in base all'inizializzazione dei valori, nell'intervallo specificato.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore che punta al primo elemento dell'intervallo al costrutto di valori.
last
Iteratore che punta a un altro oltre l'ultimo elemento dell'intervallo al costrutto di valori.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
Se viene generata un'eccezione, gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Se si verifica un errore di allocazione di memoria, viene generata un'eccezione std::bad_alloc .
Queste funzioni sono nuove in C++17.
uninitialized_value_construct_n
Costruisce un numero specificato di oggetti dell'iteratore value_type in base all'inizializzazione dei valori, a partire dalla posizione specificata.
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);
Parametri
policy
Criteri di esecuzione da usare.
first
Iteratore che punta al primo elemento dell'intervallo di destinazione da costruire.
count
Conteggio degli elementi nell'intervallo di destinazione da costruire.
Osservazioni:
La versione senza un criterio di esecuzione è in effetti identica a:
for (; count > 0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
return first;
Se viene generata un'eccezione, gli oggetti costruiti in precedenza vengono eliminati definitivamente in ordine non specificato.
La versione con un criterio di esecuzione ha lo stesso risultato, ma viene eseguita in base all'oggetto specificato policy.
Se si verifica un errore di allocazione di memoria, viene generata un'eccezione std::bad_alloc .
Queste funzioni sono nuove in C++17.
uses_allocator_v
Modello di variabile helper per accedere al valore del uses_allocator modello.
template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;