CKTIS / C++
std::make_shared — créer un objet avec une propriété partagée
std::make_shared crée un objet et renvoie un std::shared_ptr qui le gère. Pour un type autre qu’un tableau, la fonction transmet les arguments pour initialiser l’objet. Les copies du pointeur partagent le même objet et la responsabilité de sa durée de vie.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <memory>
// Non-array overload in C++23:
template<class T, class... Args>
std::shared_ptr<T> make_shared(Args&&... args);
// Usage:
auto p = std::make_shared<T>(args...);std::make_shared<T>(args...), déclaré dans <memory>, crée un objet et renvoie un std::shared_ptr<T>. Pour un type autre qu’un tableau, la fonction initialise directement un objet de type T avec T(std::forward<Args>(args)...). En C++23, cette opération n’appelle pas nécessairement de constructeur : elle permet aussi l’initialisation d’un scalaire et, lorsque la syntaxe est valide, l’initialisation d’un agrégat entre parenthèses. Après un appel réussi, use_count() vaut 1. Il existe aussi des surcharges pour les tableaux : par exemple, std::make_shared<int[]>(3) crée trois éléments de valeur 0.
Copier un std::shared_ptr permet de partager l’objet au lieu de le copier. La destruction d’une copie diminue le nombre de propriétaires ; l’objet est détruit lorsque le dernier propriétaire renonce à sa part de propriété. Dans l’exemple, second modifie le même Counter que celui pointé par first. À la fin du bloc interne, le nombre de propriétaires passe de 2 à 1.
La norme recommande au plus une allocation, sans toutefois la garantir. Si l’allocation ou un constructeur lève une exception, il n’y a pas de fuite de mémoire liée à l’objet en cours de création. La fonction n’accepte pas de fonction de suppression personnalisée. Si l’initialisation appelle un constructeur, celui-ci doit être accessible depuis le contexte de la bibliothèque, et pas seulement depuis le site d’appel.
Cette entrée concerne C++23. Le document lié est un projet de norme en cours d’évolution et peut inclure des changements ultérieurs ; la syntaxe affichée omet délibérément constexpr. Une option du compilateur dans le dépôt ne permet pas d’attester l’environnement de production.
Exemples
#include <iostream>
#include <memory>
struct Counter {
int value;
explicit Counter(int initial) : value(initial) {}
};
int main() {
auto first = std::make_shared<Counter>(7);
{
auto second = first;
++second->value;
std::cout << first->value << ' ' << first.use_count() << '\n';
}
std::cout << first->value << ' ' << first.use_count() << '\n';
}
Résultat
8 2 8 1
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.