std:: make_shared, std:: make_shared_for_overwrite

Alloue de la mémoire pour un objet et initialise l'objet avec les arguments fournis. Retourne un std::shared_ptr gérant l'objet nouvellement créé.

Paramètres

Valeur de retour

std::shared_ptr vers un objet de type T ou std:: remove_extent_t < T > [ N ] si T est un type de tableau non borné (depuis C++20) .

Pour le std::shared_ptr r retourné, r. get ( ) renvoie un pointeur non nul et r. use_count ( ) renvoie 1 .

Exceptions

Peut lever std::bad_alloc ou toute exception levée par le constructeur de T . Si une exception est levée, les fonctions n'ont aucun effet. Si une exception est levée durant la construction du tableau, les éléments déjà initialisés sont détruits dans l'ordre inverse. (depuis C++20)

Notes

Ces fonctions allouent généralement plus de mémoire que sizeof ( T ) pour permettre des structures de gestion internes telles que les compteurs de référence.

Ces fonctions peuvent être utilisées comme alternative à std:: shared_ptr < T > ( new T ( args... ) ) . Les compromis sont :

• std:: shared_ptr < T > ( new T ( args... ) ) effectue au moins deux allocations (une pour l'objet T et une pour le bloc de contrôle du pointeur partagé), tandis que std :: make_shared < T > effectue généralement une seule allocation (la norme le recommande, mais ne l'exige pas ; toutes les implémentations connues le font).
• Si un std::weak_ptr référence le bloc de contrôle créé par std::make_shared après la fin de la durée de vie de tous les propriétaires partagés, la mémoire occupée par T persiste jusqu'à ce que tous les propriétaires faibles soient également détruits, ce qui peut être indésirable si sizeof ( T ) est important.
• std:: shared_ptr < T > ( new T ( args... ) ) peut appeler un constructeur non public de T s'il est exécuté dans un contexte où il est accessible, tandis que std::make_shared nécessite un accès public au constructeur sélectionné.
• Contrairement aux constructeurs de std::shared_ptr , std::make_shared n'autorise pas de suppresseur personnalisé.
• std::make_shared utilise :: new , donc si un comportement spécial a été configuré en utilisant un operator new spécifique à la classe, il différera de std:: shared_ptr < T > ( new T ( args... ) ) .

Un constructeur active shared_from_this avec un pointeur ptr de type U* signifie qu'il détermine si U possède une classe de base non ambiguë et accessible (depuis C++17) qui est une spécialisation de std::enable_shared_from_this , et si c'est le cas, le constructeur évalue if ( ptr ! = nullptr && ptr - > weak_this  . expired ( ) )
ptr - > weak_this = std:: shared_ptr < std:: remove_cv_t < U >>
( * this, const_cast < std:: remove_cv_t < U > * > ( ptr ) ) ; .

L'assignation à weak_this n'est pas atomique et entre en conflit avec tout accès potentiellement concurrent au même objet. Cela garantit que les appels futurs à shared_from_this() partageront la propriété avec le std::shared_ptr créé par ce constructeur de pointeur brut.

Le test ptr - > weak_this  . expired ( ) dans le code ci-dessus garantit que weak_this n'est pas réaffecté s'il indique déjà un propriétaire. Ce test est requis à partir de C++17.

Exemple

#include <iostream>
#include <memory>
#include <type_traits>
#include <vector>
struct C
{
    // constructeurs nécessaires (jusqu'à C++20)
    C(int i) : i(i) {}
    C(int i, float f) : i(i), f(f) {}
    int i;
    float f{};
};
int main()
{
    // utilisation de « auto » pour le type de « sp1 »
    auto sp1 = std::make_shared<C>(1); // surcharge (1)
    static_assert(std::is_same_v<decltype(sp1), std::shared_ptr<C>>);
    std::cout << "sp1->{ i:" << sp1->i << ", f:" << sp1->f << " }\n";
    // être explicite avec le type de « sp2 »
    std::shared_ptr<C> sp2 = std::make_shared<C>(2, 3.0f); // surcharge (1)
    static_assert(std::is_same_v<decltype(sp2), std::shared_ptr<C>>);
    static_assert(std::is_same_v<decltype(sp1), decltype(sp2)>);
    std::cout << "sp2->{ i:" << sp2->i << ", f:" << sp2->f << " }\n";
    // shared_ptr vers un float[64] initialisé par valeur ; surcharge (2):
    std::shared_ptr<float[]> sp3 = std::make_shared<float[]>(64);
    // shared_ptr vers un long[5][3][4] initialisé par valeur ; surcharge (2) :
    std::shared_ptr<long[][3][4]> sp4 = std::make_shared<long[][3][4]>(5);
    // shared_ptr vers un short[128] initialisé par valeur ; surcharge (3) :
    std::shared_ptr<short[128]> sp5 = std::make_shared<short[128]>();
    // shared_ptr vers un int[7][6][5] initialisé par valeur ; surcharge (3) :
    std::shared_ptr<int[7][6][5]> sp6 = std::make_shared<int[7][6][5]>();
    // shared_ptr vers un double[256], où chaque élément est 2.0 ; surcharge (4) :
    std::shared_ptr<double[]> sp7 = std::make_shared<double[]>(256, 2.0);
    // shared_ptr vers un double[7][2], où chaque double[2]
    // element est {3.0, 4.0}; surcharge (4):
    std::shared_ptr<double[][2]> sp8 = std::make_shared<double[][2]>(7, {3.0, 4.0});
    // shared_ptr vers un vector<int>[4], où chaque vector
    // a pour contenu {5, 6}; surcharge (4) :
    std::shared_ptr<std::vector<int>[]> sp9 =
        std::make_shared<std::vector<int>[]>(4, {5, 6});
    // shared_ptr vers un float[512], où chaque élément est 1.0 ; surcharge (5) :
    std::shared_ptr<float[512]> spA = std::make_shared<float[512]>(1.0);
    // shared_ptr vers un double[6][2], où chaque élément double[2]
    // est {1.0, 2.0}; surcharge (5):
    std::shared_ptr<double[6][2]> spB = std::make_shared<double[6][2]>({1.0, 2.0});
    // shared_ptr vers un vector<int>[4], où chaque vector
    // a pour contenu {5, 6} ; surcharge (5) :
    std::shared_ptr<std::vector<int>[4]> spC =
        std::make_shared<std::vector<int>[4]>({5, 6});
}

sp1->{ i:1, f:0 }
sp2->{ i:2, f:3 }

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi