Namespaces
Variants

std::experimental::shared_ptr<T>:: shared_ptr

From cppreference.net
C++
Experimental
Library fundamentals
std::experimental::shared_ptr
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises HTML et contient des termes spécifiques au C++. Seul le numéro "(9)" pourrait être considéré comme du texte, mais il s'agit d'une référence numérique qui ne nécessite pas de traduction. **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises spécifiques au code et contient des termes techniques C++. Seul le texte en dehors des balises de code aurait dû être traduit, mais dans cet extrait, il n'y a pas de texte non-C++ à traduire. **Note:** La traduction n'a pas été effectuée car : - Le texte contenu est principalement du code C++ (balises ` `) - Les termes spécifiques au C++ (`template`, `class`, `shared_ptr`, `unique_ptr`, etc.) ne doivent pas être traduits - La structure HTML et les attributs doivent être préservés - Le numéro "(13)" fait partie de la documentation technique et ne nécessite pas de traduction Le contenu reste donc identique à l'original, conformément aux instructions.
constexpr shared_ptr ( ) noexcept ;
(1)
constexpr shared_ptr ( std:: nullptr_t ) noexcept ;
(2)
template < class Y >
explicit shared_ptr ( Y * ptr ) ;
(3)
template < class Y, class Deleter >
shared_ptr ( Y * ptr, Deleter d ) ;
(4)
template < class Deleter >
shared_ptr ( std:: nullptr_t ptr, Deleter d ) ;
(5)
template < class Y, class Deleter, class Alloc >
shared_ptr ( Y * ptr, Deleter d, Alloc alloc ) ;
(6)
template < class Deleter, class Alloc >
shared_ptr ( std:: nullptr_t ptr, Deleter d, Alloc alloc ) ;
(7)
template < class Y >
shared_ptr ( const shared_ptr < Y > & r, element_type * ptr ) noexcept ;
(8)
shared_ptr ( const shared_ptr & r ) noexcept ;
(9)
template < class Y >
shared_ptr ( const shared_ptr < Y > & r ) noexcept ;
(9)
shared_ptr ( shared_ptr && r ) noexcept ;
(10)
template < class Y >
shared_ptr ( shared_ptr < Y > && r ) noexcept ;
(10)
template < class Y >
explicit shared_ptr ( const std:: weak_ptr < Y > & r ) ;
(11)
template < class Y >
shared_ptr ( std:: auto_ptr < Y > && r ) ;
(12)
template < class Y, class Deleter >
shared_ptr ( std:: unique_ptr < Y,Deleter > && r ) ;
(13)

Construit un nouveau shared_ptr à partir de divers types de pointeurs qui référencent un objet à gérer.

Aux fins de la description ci-dessous, un type pointeur Y* est dit compatible avec un type pointeur T* si soit Y* est convertible en T* , soit Y est le type tableau U[N] et T est U cv [] (où cv est un ensemble de qualifications cv).

1,2) Construit un shared_ptr sans objet géré, c'est-à-dire un shared_ptr vide.
3-7) Construit un shared_ptr avec ptr comme pointeur vers l'objet géré. Si T est un type tableau U[N] , Y(*)[N] doit être convertible en T* . Si T est un type tableau U[] , Y(*)[] doit être convertible en T* . Sinon, Y* doit être convertible en T* . De plus :
3) Utilise une delete-expression ( delete ptr , si T n'est pas un type tableau ; delete [ ] ptr si T est un type tableau) comme suppresseur. Y doit être un type complet. Cette expression delete doit être bien formée, avoir un comportement bien défini et ne lever aucune exception.
4,5) Utilise le suppresseur spécifié d comme suppresseur. L'expression d ( ptr ) doit être bien formée, avoir un comportement bien défini et ne lever aucune exception. Deleter doit être CopyConstructible , et son constructeur de copie et son destructeur ne doivent pas lever d'exceptions.
6,7) Identique à (4,5) , mais utilise en plus une copie de alloc pour l'allocation des données à usage interne. Alloc doit être un Allocator , et son constructeur de copie et son destructeur ne doivent pas lever d'exceptions.
8) Le constructeur d'aliasing : construit un shared_ptr qui partage les informations de propriété avec r , mais contient un pointeur non lié et non géré ptr . Même si ce shared_ptr est le dernier du groupe à sortir de la portée, il appellera le destructeur pour l'objet initialement géré par r . Cependant, l'appel à get() sur celui-ci retournera toujours une copie de ptr . Il est de la responsabilité du programmeur de s'assurer que ce ptr reste valide tant que ce shared_ptr existe, comme dans les cas d'utilisation typiques où ptr est un membre de l'objet géré par r ou est un alias (par exemple, downcast) de r. get ( ) .
9) Construit un shared_ptr qui partage la propriété de l'objet géré par r . Si r ne gère aucun objet, * this ne gère aucun objet non plus. La surcharge de modèle ne participe pas à la résolution de surcharge si Y* n'est pas compatible avec T* .
10) Construit par déplacement un shared_ptr à partir de r . Après la construction, * this contient une copie de l'état précédent de r , r est vide. La surcharge du modèle ne participe pas à la résolution de surcharge si Y* n'est pas compatible avec T* .
11) Construit un shared_ptr qui partage la propriété de l'objet géré par r . Y* doit être compatible avec T* . Notez que r. lock ( ) peut être utilisé dans le même but : la différence est que ce constructeur lance une exception si l'argument est vide, tandis que weak_ptr < T > :: lock ( ) construit un shared_ptr vide dans ce cas.
12) Construit un shared_ptr qui stocke et possède l'objet précédemment détenu par r . Y* doit être convertible en T* . Après la construction, r est vide.
13) Construit un shared_ptr qui gère l'objet actuellement géré par r . Le suppresseur associé à r est stocké pour la suppression future de l'objet géré. r ne gère plus aucun objet après l'appel. Cette surcharge ne participe pas à la résolution de surcharge si Y* n'est pas compatible avec T* .
Si D est un type référence, équivalent à shared_ptr ( r. release ( ) , std:: ref ( r. get_deleter ( ) ) . Sinon, équivalent à shared_ptr ( r. release ( ) , r. get_deleter ( ) ) .

Table des matières

Notes

Lors de la construction d'un shared_ptr à partir d'un pointeur brut vers un objet d'un type dérivé de std::experimental::enable_shared_from_this , les constructeurs de shared_ptr mettent à jour le membre privé weak_ptr de la classe de base std::experimental::enable_shared_from_this afin que les appels futurs à shared_from_this() partagent la propriété avec le shared_ptr créé par ce constructeur à partir d'un pointeur brut.

Les surcharges de pointeur brut prennent la propriété de l'objet pointé, et donc la construction d'un shared_ptr en utilisant la surcharge de pointeur brut pour un objet déjà géré par un shared_ptr peut conduire à un comportement indéfini, même si l'objet est d'un type dérivé de std::experimental::enable_shared_from_this .

Paramètres

ptr - un pointeur vers un objet à gérer
d - un suppresseur à utiliser pour détruire l'objet
alloc - un allocateur à utiliser pour les allocations de données à usage interne
r - un autre pointeur intelligent avec lequel partager la propriété ou dont acquérir la propriété

Exceptions

3) std::bad_alloc si la mémoire supplémentaire requise n'a pas pu être obtenue. Peut lever une exception définie par l'implémentation pour d'autres erreurs. L'expression delete applicable ( delete ptr si T n'est pas un type tableau, delete [ ] ptr sinon) est appelée si une exception se produit.
4-7) std::bad_alloc si la mémoire supplémentaire requise n'a pas pu être obtenue. Peut lever une exception définie par l'implémentation pour d'autres erreurs. d ( ptr ) est appelée si une exception se produit.
11) std::bad_weak_ptr si r. expired ( ) == true . Le constructeur n'a aucun effet dans ce cas.
12) std::bad_alloc si la mémoire supplémentaire requise n'a pas pu être obtenue. Peut lever une exception définie par l'implémentation pour d'autres erreurs. Ce constructeur n'a aucun effet si une exception se produit.
13) Si une exception est levée, le constructeur n'a aucun effet.

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

(C++20)
crée un pointeur partagé qui gère un nouvel objet
(modèle de fonction)
(C++20)
crée un pointeur partagé qui gère un nouvel objet alloué à l'aide d'un allocateur
(modèle de fonction)