fonctions<memory>
addressof
Obtient l'adresse exacte d'un objet.
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
Paramètres
value
Objet ou fonction desquels obtenir l'adresse exacte.
Valeur de retour
Adresse réelle de l'objet ou de la fonction référencés par value, même en cas de operator&() surchargé.
Notes
align
Correspond au stockage de la taille donnée, aligné par la spécification d’alignement donnée, dans la première adresse possible du stockage donné.
void* align(
size_t alignment, // input
size_t size, // input
void*& ptr, // input/output
size_t& space // input/output
);
Paramètres
alignment
Limite d'alignement à tenter.
size
Taille en octets du stockage aligné.
ptr
Adresse de départ du pool de stockage contigu disponible à utiliser. Ce paramètre est également un paramètre de sortie et est défini pour contenir la nouvelle adresse de départ si l’alignement réussit. En align() cas d’échec, ce paramètre n’est pas modifié.
space
Espace total disponible pour align() pour la création du stockage aligné. Ce paramètre est également un paramètre de sortie. Il contient l'espace ajusté restant dans la mémoire tampon de stockage une fois le stockage aligné et toute surcharge associée soustraite.
En align() cas d’échec, ce paramètre n’est pas modifié.
Valeur de retour
Pointeur NULL si la mémoire tampon alignée demandée ne serait pas adaptée à l’espace disponible ; sinon, la nouvelle valeur de ptr.
Notes
Les paramètres modifiés ptr et space permettent d'appeler align() à plusieurs reprises pour la même mémoire tampon, éventuellement avec des valeurs différentes pour alignment et size. L'extrait de code suivant illustre une utilisation de 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
Crée un shared_ptr pour les objets qui sont alloués et construits pour un type donné en utilisant un allocateur spécifié. Retourne l'shared_ptr.
template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
Allocator alloc,
Args&&... args);
Paramètres
alloc
Allocateur utilisé pour créer les objets.
args
Zéro ou plusieurs arguments qui deviennent les objets.
Notes
La fonction crée l’objet shared_ptr<T>, un pointeur vers T(args...) tel qu’alloué et construit par 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
Cast de type const vers 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;
Paramètres
T
Type contrôlé par le pointeur partagé retourné.
Other
Type contrôlé par le pointeur partagé d’argument.
sp
Pointeur partagé d’argument.
Notes
La fonction de modèle retourne un objet vide shared_ptr si elle renvoie un pointeur Null ; sinon, elle renvoie un shared_ptr<T> objet propriétaire de la ressource détenue par spconst_cast<T*>(sp.get()) . L'expression const_cast<T*>(sp.get()) doit être valide.
Exemple
// 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
Informe un récupérateur de mémoire que les caractères dans le bloc de mémoire défini par un pointeur d’adresse de base et une taille de bloc ne contiennent aucun pointeur traçable.
void declare_no_pointers(
char* ptr,
size_t size);
Paramètres
ptr
Adresse du premier caractère qui ne contient plus de pointeur traçable.
size
Taille du bloc qui commence à ptr qui ne contient aucun pointeur traçable.
Notes
La fonction informe tout garbage collector que les adresses de la plage [ptr, ptr + size) ne contiennent plus de pointeurs traceables. (Les pointeurs vers le stockage alloué ne doivent pas être déréférencements, sauf s’ils sont accessibles.)
declare_reachable
Informe une opération garbage collection que l’adresse indiquée est dédiée au stockage alloué et est accessible.
void declare_reachable(
void* ptr);
Paramètres
ptr
Pointeur vers une zone de stockage accessible, allouée et valide.
Notes
Si ptr elle n’est pas null, la fonction informe tout garbage collector désormais ptr accessible, autrement dit, il pointe vers un stockage alloué valide.
default_delete
Supprime les objets alloués avec operator new. Fonction pouvant être utilisée avec 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;
};
Paramètres
ptr
Pointeur vers l'objet à supprimer.
Other
Type des éléments dans le tableau à supprimer.
Notes
Le modèle de classe décrit un deleter qui supprime les objets scalaires alloués avec operator new, adapté à une utilisation avec le modèle unique_ptrde classe . Il possède également la spécialisation explicite default_delete<T[]>.
destroy_at
template <class T>
void destroy_at(
T* location);
Comme pour location->~T().
destroy
template <class ForwardIterator>
void destroy(
ForwardIterator first,
ForwardIterator last);
Identique à :
for (; first != last; ++first)
destroy_at(addressof(*first));
destroy_n
template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
ForwardIterator first,
Size count);
Identique à :
for (; count > 0; (void)++first, --count)
destroy_at(addressof(*first));
return first;
dynamic_pointer_cast
Cast dynamique vers 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;
Paramètres
T
Type contrôlé par le pointeur partagé retourné.
Other
Type contrôlé par le pointeur partagé d’argument.
sp
Pointeur partagé d’argument.
Notes
La fonction de modèle retourne un objet vide shared_ptr si elle renvoie un pointeur Null ; sinon, elle renvoie un shared_ptr<T> objet propriétaire de la ressource détenue par spdynamic_cast<T*>(sp.get()) . L'expression dynamic_cast<T*>(sp.get()) doit être valide.
Exemple
// 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
Obtenir le deleter d’un shared_ptr.
template <class Deleter, class T>
Deleter* get_deleter(
const shared_ptr<T>& sp) noexcept;
Paramètres
Deleter
Type du suppresseur.
T
Type contrôlé par le pointeur partagé.
sp
Pointeur partagé.
Notes
La fonction de modèle retourne un pointeur vers le deleter de type Deleter qui appartient à l’objet shared_ptr sp. Si sp elle n’a pas de deleter ou si son deleter n’est pas de type Deleter, la fonction retourne 0.
Exemple
// 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
Retourne le type de sécurité de pointeur supposé par tout récupérateur de mémoire.
pointer_safety get_pointer_safety() noexcept;
Notes
La fonction retourne le type de sécurité du pointeur supposé par n’importe quel garbage collector automatique.
get_temporary_buffer
Alloue un stockage temporaire pour une séquence d’éléments qui ne dépasse pas un nombre spécifié d’éléments.
template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
ptrdiff_t count);
Paramètres
count
Nombre maximal d’éléments demandés pour lesquels la mémoire doit être allouée.
Valeur de retour
pair dont le premier composant est un pointeur vers la mémoire qui a été allouée, et dont le deuxième composant donne la taille de la mémoire tampon, indiquant le nombre d’éléments le plus élevé qu’elle puisse stocker.
Notes
La fonction effectue une demande de mémoire qui présente des risques d’échec. Si aucune mémoire tampon n’est allouée, la fonction retourne une paire dans laquelle le deuxième élément est égal à zéro et le premier élément est égal au pointeur Null.
Utilisez uniquement cette fonction pour la mémoire temporaire.
Exemple
// 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
Crée et retourne un pointeur shared_ptr qui pointe vers les objets alloués qui sont construits de zéro ou de plusieurs arguments à l'aide de l'allocateur par défaut. Alloue et construit un objet du type spécifié et un pointeur shared_ptr pour gérer une propriété partagée de l'objet et retourne le pointeur shared_ptr.
template <class T, class... Args>
shared_ptr<T> make_shared(
Args&&... args);
Paramètres
args
Zéro ou plusieurs arguments de constructeur. Selon les arguments fournis, la fonction déduit la surcharge de constructeur à appeler.
Notes
Utilisez make_shared comme un moyen simple et plus efficace pour créer un objet et un pointeur shared_ptr pour gérer l'accès partagé à l'objet en même temps. Sémantiquement, les deux instructions suivantes sont équivalentes :
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
Toutefois, la première instruction crée deux allocations, et si l'allocation du pointeur shared_ptr échoue alors que l'allocation de l'objet Example a réussi, l'objet sans nom Example est victime d'une fuite. L'instruction qui utilise make_shared est plus simple car un seul appel de fonction est impliqué. Elle est plus efficace car la bibliothèque peut effectuer une allocation unique pour l'objet et le pointeur intelligent. Cette fonction est à la fois plus rapide et entraîne moins de fragmentation de la mémoire, et il n’y a aucune chance d’une exception sur une allocation, mais pas l’autre. Les performances sont améliorées grâce à une meilleure localité du code qui fait référence à l'objet et qui met à jour les décomptes de références dans le pointeur intelligent.
Envisagez d’utiliser make_unique si vous n’avez pas besoin d’un accès partagé à l’objet. Utilisez cette option allocate_shared si vous devez spécifier un allocateur personnalisé pour l’objet. Vous ne pouvez pas utiliser make_shared si votre objet nécessite un deleter personnalisé, car il n’existe aucun moyen de passer le deleter en tant qu’argument.
L'exemple suivant illustre la création de pointeurs partagés vers un type en appelant des surcharges de constructeur spécifiques.
Exemple
// 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'exemple génère cette sortie :
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
Crée et retourne un unique_ptr objet du type spécifié, qui est construit à l’aide des arguments spécifiés.
// 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;
Paramètres
T
Type de l’objet vers lequel pointera le unique_ptr.
Args
Types des arguments de constructeur spécifiés par args.
args
Arguments à passer au constructeur de l’objet de type T.
elements
Tableau d’éléments de type T.
size
Nombre d’éléments pour lesquels allouer de l’espace dans le nouveau tableau.
Notes
La première surcharge est utilisée pour les objets uniques. La deuxième surcharge est appelée pour les tableaux. La troisième surcharge vous empêche de spécifier une taille de tableau dans l’argument de type (make_unique<T[N]>). Cette construction n’est pas prise en charge par la norme actuelle. Quand vous utilisez make_unique pour créer un unique_ptr dans un tableau, vous devez initialiser les éléments du tableau séparément. Plutôt que d’utiliser cette surcharge, peut-être un meilleur choix consiste à utiliser un std::vector.
make_unique étant implémentée soigneusement pour la protection contre les exceptions, nous vous recommandons d’utiliser make_unique au lieu d’appeler directement des constructeurs unique_ptr.
Exemple
L'exemple suivant montre comment utiliser make_unique. Pour obtenir plus d’exemples, consultez Guide pratique pour créer et utiliser des instances 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();
}
Quand vous voyez l’erreur C2280 en lien avec unique_ptr, il est presque certain que vous essayez d’appeler son constructeur de recopie, qui est une fonction supprimée.
owner_less
Permet des comparaisons mixtes basées sur la propriété de pointeurs partagés et faibles. Retourne true si le paramètre de gauche est ajouté avant le paramètre de droite par la fonction membre owner_before.
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;
};
Paramètres
left
Pointeur partagé ou faible.
right
Pointeur partagé ou faible.
Notes
Les modèles de classe définissent tous leurs opérateurs membres comme retournant left.owner_before(right).
reinterpret_pointer_cast
Crée un shared_ptr pointeur partagé existant à l’aide d’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;
Paramètres
ptr
Référence à un shared_ptr<U>.
Notes
S’il ptr est vide, le nouveau shared_ptr est également vide, sinon il partage la propriété avec ptr. Le nouveau pointeur partagé est le résultat de l’évaluation reinterpret_cast<Y*>(ptr.get()), où Y est typename std::shared_ptr<T>::element_type. Le comportement n’est pas défini s’il reinterpret_cast<T*>((U*)nullptr) n’est pas bien formé.
La fonction de modèle qui prend une référence lvalue est nouvelle en C++17. La fonction de modèle qui prend une référence rvalue est nouvelle en C++20.
return_temporary_buffer
Libère la mémoire temporaire allouée à l'aide de la fonction de modèle get_temporary_buffer.
template <class T>
void return_temporary_buffer(
T* buffer);
Paramètres
buffer
Pointeur vers la mémoire à libérer.
Notes
Utilisez uniquement cette fonction pour la mémoire temporaire.
Exemple
// 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
Cast statique vers 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;
Paramètres
T
Type contrôlé par le pointeur partagé retourné.
Other
Type contrôlé par le pointeur partagé d’argument.
sp
Pointeur partagé d’argument.
Notes
La fonction de modèle retourne un objet vide shared_ptr s’il sp s’agit d’un objet vide shared_ptr ; sinon, il renvoie un shared_ptr<T> objet propriétaire de la ressource détenue par sp. L'expression static_cast<T*>(sp.get()) doit être valide.
Exemple
// 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
Échangez deux objets, unique_ptrou weak_ptr deux shared_ptrobjets.
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;
Paramètres
T
Type contrôlé par le pointeur d’argument.
Deleter
Deleter du type de pointeur unique.
left
Pointeur gauche.
right
Pointeur droit.
Notes
Les fonctions de modèle appellent left.swap(right).
Exemple
// 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
Informe un récupérateur de mémoire que les caractères dans le bloc de mémoire défini par un pointeur d'adresse de base et une taille de bloc peuvent maintenant contenir des pointeurs traçables.
void undeclare_no_pointers(
char* ptr,
size_t size);
Paramètres
ptr
Pointeur vers l’adresse mémoire précédemment marquée à l’aide declare_no_pointersde .
size
Nombre d’octets dans la plage de mémoire. Cette valeur doit être égale au nombre utilisé dans l’appel declare_no_pointers .
Notes
La fonction informe tout garbage collector que la plage d’adresses [ptr, ptr + size) peut désormais contenir des pointeurs traceables.
undeclare_reachable
Révoque une déclaration d’accessibilité pour un emplacement de mémoire spécifié.
template <class T>
T *undeclare_reachable(
T* ptr);
Paramètres
ptr
Pointeur vers l’adresse mémoire précédemment marquée à l’aide declare_reachablede .
Notes
Si ptr ce n’est pas nullptrle cas, la fonction informe tout garbage collector qui ptr n’est plus accessible. Elle retourne un pointeur dérivé en toute sécurité qui est égal à ptr.
uninitialized_copy
Copie les objets d'une plage source spécifiée dans une plage de destination non initialisée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur d'entrée qui traite le premier élément de la plage source.
last
Itérateur d'entrée qui traite le dernier élément de la plage source.
dest
Itérateur vers l’avant qui traite le premier élément de la plage de destination.
Valeur de retour
Itérateur vers l’avant qui traite la première position au-delà de la plage de destination, sauf si la plage source était vide.
Notes
Cet algorithme permet de découpler l'allocation de mémoire et la construction d'objet.
La fonction de modèle est exécutée :
while (first != last)
{
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;
à moins que le code ne provoque la levée d'une exception. Dans ce cas, tous les objets construits sont détruits et l’exception est de nouveau levée.
La surcharge avec une stratégie d’exécution est nouvelle en C++17.
Exemple
// 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
Crée une copie d'un nombre spécifié d'éléments à partir d'un itérateur d'entrée. Les copies sont placées dans un itérateur vers l’avant.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur d'entrée qui fait référence à l'objet à copier.
count
Type entier signé ou non signé spécifiant le nombre de fois que l'objet doit être copié.
dest
Itérateur vers l’avant qui fait référence à l'emplacement des nouvelles copies.
Valeur de retour
Itérateur vers l’avant qui traite la première position au-delà de la destination. Si la plage source était vide, les adresses firstd’itérateur .
Notes
La fonction de modèle exécute efficacement le code suivant :
for (; 0 < count; --count)
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
return dest;
à moins que le code ne provoque la levée d'une exception. Dans ce cas, tous les objets construits sont détruits et l’exception est de nouveau levée.
La surcharge avec une stratégie d’exécution est nouvelle en C++17.
uninitialized_default_construct
La valeur par défaut construit les objets des itérateurs dans value_type la plage spécifiée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur qui traite le premier élément de la plage à construire.
last
Itérateur ciblant un dernier élément de la plage à construire.
Notes
La version sans stratégie d’exécution est effectivement la même que :
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
Si une exception est levée, les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Ces fonctions sont nouvelles en C++17.
uninitialized_default_construct_n
La valeur par défaut construit un nombre spécifié d’objets de l’itérateur, en commençant à l’emplacement value_typespécifié.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur qui traite le premier élément de la plage de destination à construire.
count
Nombre d’éléments de la plage de destination à construire.
Valeur de retour
Itérateur vers l’avant qui traite la première position au-delà de la plage de destination, sauf si la plage source était vide.
Notes
La version sans stratégie d’exécution est effectivement la même que :
for (; count>0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
return first;
Si une exception est levée, les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Ces fonctions sont nouvelles en C++17.
uninitialized_fill
Copie les objets d'une valeur spécifiée dans une plage de destination non initialisée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur avant qui traite le premier élément de la plage de destination à initialiser.
last
Itérateur avant qui traite le dernier élément de la plage de destination à initialiser.
value
Valeur à utiliser pour initialiser la plage de destination.
Notes
Cet algorithme permet de découpler l'allocation de mémoire et la construction d'objet.
La fonction de modèle est exécutée :
while (first != last)
new (static_cast<void*>(&* first ++))
typename iterator_traits<ForwardIterator>::value_type (value);
à moins que le code ne provoque la levée d'une exception. Dans ce cas, tous les objets construits sont détruits et l’exception est de nouveau levée.
La surcharge avec une stratégie d’exécution est nouvelle en C++17.
Exemple
// 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
Copie les objets d’une valeur spécifiée dans le nombre spécifié d’éléments d’une plage de destination non initialisée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur avant qui traite le premier élément de la plage de destination à initialiser.
count
Nombre d’éléments à initialiser.
value
Valeur à utiliser pour initialiser la plage de destination.
Notes
Cet algorithme permet de découpler l'allocation de mémoire et la construction d'objet.
La fonction de modèle est exécutée :
while (0 < count--)
new (static_cast<void*>(&* first++))
typename iterator_traits<ForwardIterator>::value_type(value);
return first;
à moins que le code ne provoque la levée d'une exception. Dans ce cas, tous les objets construits sont détruits et l’exception est de nouveau levée.
La surcharge avec une stratégie d’exécution est nouvelle en C++17.
Exemple
// 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
Déplace les éléments d’une plage source vers une zone mémoire de destination non initialisée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur d’entrée qui traite le premier élément de la plage source à déplacer.
last
Itérateur d’entrée ciblant un dernier élément de la plage source à déplacer.
dest
Début de la plage de destination.
Notes
La version sans stratégie d’exécution est effectivement la même que :
for (; first != last; (void)++dest, ++first)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;
Si une exception est levée, certains objets de la plage source peuvent être laissés dans un état valide mais non spécifié. Les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Ces fonctions sont nouvelles en C++17.
uninitialized_move_n
Déplace un nombre spécifié d’éléments d’une plage source vers une zone mémoire de destination non initialisée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur d’entrée qui traite le premier élément de la plage source à déplacer.
count
Nombre d’éléments dans la plage source à déplacer.
dest
Début de la plage de destination.
Notes
La version sans stratégie d’exécution est effectivement la même que :
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};
Si une exception est levée, certains objets de la plage source peuvent être laissés dans un état valide mais non spécifié. Les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Ces fonctions sont nouvelles en C++17.
uninitialized_value_construct
Construit des objets des itérateurs value_type par initialisation par valeur, dans la plage spécifiée.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur qui traite le premier élément de la plage à construire.
last
Itérateur ciblant un dernier élément de la plage à construire.
Notes
La version sans stratégie d’exécution est effectivement la même que :
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
Si une exception est levée, les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Si un échec d’allocation de mémoire se produit, une std::bad_alloc exception est levée.
Ces fonctions sont nouvelles en C++17.
uninitialized_value_construct_n
Construit un nombre spécifié d’objets de l’itérateur value_type par initialisation par valeur, en commençant à l’emplacement spécifié.
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);
Paramètres
policy
Stratégie d’exécution à utiliser.
first
Itérateur qui traite le premier élément de la plage de destination à construire.
count
Nombre d’éléments de la plage de destination à construire.
Notes
La version sans stratégie d’exécution est effectivement la même que :
for (; count > 0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
return first;
Si une exception est levée, les objets précédemment construits sont détruits dans un ordre non spécifié.
La version avec une stratégie d’exécution a le même résultat, mais s’exécute en fonction de l’élément spécifié policy.
Si un échec d’allocation de mémoire se produit, une std::bad_alloc exception est levée.
Ces fonctions sont nouvelles en C++17.
uses_allocator_v
Modèle de variable d’assistance pour accéder à la valeur du uses_allocator modèle.
template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;