CKTIS / C++
std::make_shared — een object maken met gedeeld eigenaarschap
std::make_shared maakt een object en geeft een std::shared_ptr terug die het beheert. Voor een niet-arraytype geeft de functie de argumenten door om het object te initialiseren. Kopieën van de pointer delen hetzelfde object en de verantwoordelijkheid voor de levensduur ervan.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
#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...), gedeclareerd in <memory>, maakt een object en geeft een std::shared_ptr<T> terug. Voor een niet-arraytype initialiseert de functie een object van type T rechtstreeks met T(std::forward<Args>(args)...). In C++23 hoeft dit geen constructor aan te roepen: ook initialisatie van scalaire objecten en, waar geldig, initialisatie van aggregaten met ronde haakjes zijn mogelijk. Na een geslaagde aanroep is use_count() gelijk aan 1. Er bestaan ook overloads voor arrays: std::make_shared<int[]>(3) maakt bijvoorbeeld drie elementen met de waarde 0.
Wie een std::shared_ptr kopieert, deelt het object in plaats van het te kopiëren. Wanneer een kopie wordt vernietigd, neemt het aantal eigenaars af; het object wordt vernietigd wanneer de laatste eigenaar het eigenaarschap opgeeft. In het voorbeeld wijzigt second dezelfde Counter waarnaar first wijst. Na afloop van het binnenste blok daalt het aantal eigenaars van 2 naar 1.
De standaard beveelt maximaal één allocatie aan, maar garandeert die niet. Als de allocatie of een constructor een exceptie opwerpt, lekt er geen geheugen voor het object dat werd aangemaakt. De functie accepteert geen aangepaste deleter. Als de initialisatie een constructor aanroept, moet die toegankelijk zijn vanuit de bibliotheekcontext, niet alleen vanaf de aanroepplaats.
Dit artikel betreft C++23. Het gekoppelde document is een doorlopend bijgewerkt werkdocument en kan latere wijzigingen bevatten; de weergegeven syntaxis laat constexpr bewust weg. Een compileroptie in de repository bevestigt niet wat de productieomgeving gebruikt.
Voorbeelden
#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';
}
Resultaat
8 2 8 1
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.