make_shared (<memory>)
Cria e retorna um shared_ptr que aponta para os objetos alocados construídos a partir do zero ou mais argumentos usando o alocador padrão. Aloca e constrói os dois um objeto do tipo especificado e um shared_ptr para gerenciar compartilham a propriedade do objeto e retorna o shared_ptr.
template<class Type, class... Types> shared_ptr<Type> make_shared( Types&&... _Args );
Parâmetros
Parâmetro |
Descrição |
|---|---|
_Args |
Zero ou mais argumentos de construtor. A função infere qual sobrecarga de construtor para chamar com base nos argumentos fornecidos. |
Valor da propriedade/valor de retorno
Retorna um shared_ptr que aponta para o objeto alocado e construído.
Comentários
Use make_shared como uma forma simples e mais eficiente para criar um objeto e um shared_ptr para gerenciar o acesso compartilhado para o objeto ao mesmo tempo. Semanticamente, essas duas instruções são equivalentes:
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
No entanto, a primeira instrução faz duas alocações e se a alocação do shared_ptr falhar após a alocação do Example objeto foi bem-sucedida, em seguida, sem nome Example objeto é perdido. A instrução que usa make_shared é mais simples porque há apenas uma função chamada envolvidas. É mais eficiente porque a biblioteca pode fazer uma única alocação do objeto e o ponteiro inteligente. Isso é mais rápido e resulta em menos fragmentação da memória e não há nenhuma possibilidade de uma exceção em uma alocação, mas não o outro. Desempenho é melhorado pela localidade melhor para o código que faz referência a objeto e atualizações de que contagens de referência no ponteiro inteligente.
Considere o uso de make_unique se não precisar de acesso compartilhado para o objeto. Use allocate_shared se você precisar especificar um alocador personalizado para o objeto. Não é possível usar make_shared se o objeto requer um deleter personalizado, porque não há nenhuma maneira de passar o deleter como um argumento.
O exemplo a seguir mostra como criar compartilhados ponteiros para um tipo, chamando as sobrecargas do construtor específico.
Exemplo
// stl_make_shared.cpp
// Compile by using: cl /W4 /EHsc stl_make_shared.cpp
#include <iostream>
#include <string>
#include <memory>
#include <vector>
class Song {
public:
std::wstring title_;
std::wstring artist_;
Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist) {}
Song(std::wstring title) : title_(title), artist_(L"Unknown") {}
};
void CreateSharedPointers() {
// Okay, but less efficient to have separate allocations for
// Song object and shared_ptr control block.
auto song = new Song(L"Ode to Joy", L"Beethoven");
std::shared_ptr<Song> sp0(song);
// Use make_shared function when possible. Memory for control block
// and Song object are allocated in the same call:
auto sp1 = std::make_shared<Song>(L"Yesterday", L"The Beatles");
auto sp2 = std::make_shared<Song>(L"Blackbird", L"The Beatles");
// make_shared infers which constructor to use based on the arguments.
auto sp3 = std::make_shared<Song>(L"Greensleeves");
// The playlist vector makes copies of the shared_ptr pointers.
std::vector<std::shared_ptr<Song>> playlist;
playlist.push_back(sp0);
playlist.push_back(sp1);
playlist.push_back(sp2);
playlist.push_back(sp3);
playlist.push_back(sp1);
playlist.push_back(sp2);
for (auto&& sp : playlist) {
std::wcout << L"Playing " << sp->title_ <<
L" by " << sp->artist_ << L", use count: " <<
sp.use_count() << std::endl;
}
}
int main() {
CreateSharedPointers();
}
O exemplo produz esta saída:
Requisitos
Cabeçalho: < memória >
Namespace: std