Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

make_shared (<memory>)

 

Crea y devuelve un shared_ptr que apunta a los objetos asignados que se construyen a partir de cero o más argumentos mediante el asignador predeterminado.Asigna y crea tanto un objeto del tipo especificado como un shared_ptr para administrar una propiedad compartida del objeto y devuelve el elemento shared_ptr.

template<class Type, class... Types>
    shared_ptr<Type> make_shared(
        Types&&... _Args
    );

Parámetro

Descripción

_Args

Cero o más argumentos de constructor.La función deduce qué sobrecarga de constructor invocar según los argumentos que se proporcionan.

Devuelve un shared_ptr que apunta al objeto asignado y creado.

Use make_shared como una manera más eficaz y sencilla de crear un objeto y un shared_ptr para administrar el acceso compartido al objeto al mismo tiempo.Semánticamente, estas dos instrucciones son equivalentes:

auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);

Sin embargo, la primera instrucción hace dos asignaciones y, si en la asignación de shared_ptr se produce un error después de que la asignación del objeto Example se haya realizado correctamente, el objeto Example sin nombre se pierde.La instrucción que usa make_shared es más sencilla porque hay solo una llamada a función implicada.Es más eficaz porque la biblioteca puede realizar una única asignación para tanto el objeto como el puntero inteligente.Esto es más rápido y genera menos fragmentación de la memoria y no hay ninguna posibilidad de una excepción en una asignación, pero no en la otra.El rendimiento mejora por el mejor emplazamiento del código que hace referencia al objeto y que actualiza los recuentos de referencia en el puntero inteligente.

Considere el uso de make_unique si no necesita acceso compartido al objeto.Use allocate_shared si necesita especificar un asignador personalizado para el objeto.No puede usar make_shared si el objeto requiere un eliminador personalizado, porque no hay ninguna manera de pasar el eliminador como argumento.

En el ejemplo siguiente se muestra cómo crear punteros compartidos a un tipo invocando determinadas sobrecargas de constructor.

// 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();
}

El ejemplo produce la siguiente salida:

Playing Ode to Joy by Beethoven, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
Playing Greensleeves by Unknown, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3

Requisitos

Encabezado: <memory>

Espacio de nombres: std

Mostrar: