Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::make_shared — criar um objeto com propriedade partilhada

std::make_shared cria um objeto e devolve um std::shared_ptr que o gere. Se o tipo não for um array, encaminha os argumentos para inicializar o objeto. As cópias do ponteiro partilham o mesmo objeto e a responsabilidade pelo seu tempo de vida.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#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...), declarada em <memory>, cria um objeto e devolve um std::shared_ptr<T>. Se o tipo não for um array, a função inicializa diretamente um objeto do tipo T com T(std::forward<Args>(args)...). Em C++23, isto não implica necessariamente uma chamada a um construtor: também é possível inicializar escalares e, quando a sintaxe é válida, inicializar agregados com parênteses. Após uma chamada bem-sucedida, use_count() é 1. Também existem sobrecargas para arrays: por exemplo, std::make_shared<int[]>(3) cria três elementos com o valor 0.

Ao copiar um std::shared_ptr, o objeto é partilhado em vez de ser copiado. A destruição de uma cópia reduz o número de proprietários; o objeto é destruído quando o último proprietário deixa de o possuir. No exemplo, second altera o mesmo Counter para o qual first aponta. Quando o bloco interno termina, o número de proprietários desce de 2 para 1.

A norma recomenda, no máximo, uma alocação, mas não a garante. Se a alocação ou um construtor lançar uma exceção, não fica por libertar memória destinada ao objeto que estava a ser criado. A função não aceita uma função de eliminação personalizada. Se a inicialização invocar um construtor, este tem de estar acessível a partir do contexto da biblioteca, e não apenas do local da chamada.

Esta entrada diz respeito a C++23. O documento ligado é um projeto de trabalho em evolução e pode incluir alterações posteriores; a sintaxe apresentada omite deliberadamente constexpr. Uma opção do compilador no repositório não atesta o ambiente de produção.

Exemplos

#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';
}

Resultado

8 2
8 1

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes