fonctions`<memory>`

Article
10/12/2023

`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_ptrsp. 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};

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;

Voir aussi

<memory>

fonctions<memory>

addressof

Paramètres

Valeur de retour

Notes

align

Paramètres

Valeur de retour

Notes

allocate_shared

Paramètres

Notes

atomic_compare_exchange_strong

atomic_compare_exchange_weak

atomic_compare_exchange_strong_explicit

atomic_compare_exchange_weak_explicit

atomic_exchange

atomic_exchange_explicit

atomic_is_lock_free

atomic_load

atomic_load_explicit

atomic_store

atomic_store_explicit

const_pointer_cast

Paramètres

Notes

Exemple

declare_no_pointers

Paramètres

Notes

declare_reachable

Paramètres

Notes

default_delete

Paramètres

Notes

destroy_at

destroy

destroy_n

dynamic_pointer_cast

Paramètres

Notes

Exemple

get_deleter

Paramètres

Notes

Exemple

get_pointer_safety

Notes

get_temporary_buffer

Paramètres

Valeur de retour

Notes

Exemple

make_shared

Paramètres

Notes

Exemple

make_unique

Paramètres

Notes

Exemple

owner_less

Paramètres

Notes

reinterpret_pointer_cast

Paramètres

Notes

return_temporary_buffer

Paramètres

Notes

Exemple

static_pointer_cast

Paramètres

Notes

Exemple

swap

Paramètres

Notes

Exemple

fonctions`<memory>`

`addressof`

`align`

`allocate_shared`

`atomic_compare_exchange_strong`

`atomic_compare_exchange_weak`

`atomic_compare_exchange_strong_explicit`

`atomic_compare_exchange_weak_explicit`

`atomic_exchange`

`atomic_exchange_explicit`

`atomic_is_lock_free`

`atomic_load`

`atomic_load_explicit`

`atomic_store`

`atomic_store_explicit`

`const_pointer_cast`

`declare_no_pointers`

`declare_reachable`

`default_delete`

`destroy_at`

`destroy`

`destroy_n`

`dynamic_pointer_cast`

`get_deleter`

`get_pointer_safety`

`get_temporary_buffer`

`make_shared`

`make_unique`

`owner_less`

`reinterpret_pointer_cast`

`return_temporary_buffer`

`static_pointer_cast`

`swap`

`undeclare_no_pointers`

`undeclare_reachable`

`uninitialized_copy`

`uninitialized_copy_n`

`uninitialized_default_construct`

`uninitialized_default_construct_n`

`uninitialized_fill`

`uninitialized_fill_n`

`uninitialized_move`

`uninitialized_move_n`

`uninitialized_value_construct`

`uninitialized_value_construct_n`

`uses_allocator_v`