`std::make_shared` în C++

Creează un obiect și un std::shared_ptr care îl deține, cu o singură alocare de memorie.

Sintaxă

template<class T, class... Args>
std::shared_ptr<T> make_shared(Args&&... argumente);

Ce face `std::make_shared`

std::make_shared<T>(argumente) construiește obiectul și returnează un std::shared_ptr<T> cu contorul la 1. Argumentele merg direct la constructorul lui T.

Față de std::shared_ptr<T>(new T(...)), face o singură alocare (obiectul și contorul stau împreună), deci este mai rapid, și nu scrii new.

Parametri

Parametru	Descriere
`argumente`	Valorile trimise constructorului lui `T`.

Ce returnează

Un std::shared_ptr<T> către obiectul nou.

Exemple

Exemplul 1: Un coș de cumpărături comun

#include <memory>
#include <print>
#include <string>
#include <vector>

int main() {
    auto cos = std::make_shared<std::vector<std::string>>();
    auto acelasiCos = cos;

    cos->push_back("pâine");
    acelasiCos->push_back("lapte");

    std::println("{} produse, {} proprietari", cos->size(), cos.use_count());
    for (const auto& p : *cos) {
        std::println("- {}", p);
    }
}

Rezultat

2 produse, 2 proprietari
- pâine
- lapte

Greșeli frecvente

Folosești make_shared pentru un obiect care are un singur proprietar. Alege std::make_unique; un unique_ptr se poate transforma oricând în shared_ptr (prin std::move).

Comenzi înrudite

std::shared_ptr: Pointer inteligent cu proprietate comună: obiectul este șters când ultimul shared_ptr dispare.
std::make_unique: Creează un obiect pe heap și returnează un std::unique_ptr care îl deține.
std::weak_ptr: Referință slabă la un obiect deținut de shared_ptr: nu îl ține în viață; lock() îl folosește în siguranță.

Ce face std::make_shared