puntero único - ¿Por qué es el destructor llama 3 veces

Tobi S .:

Tengo un método que devuelve un objeto por valor. El método proviene de una biblioteca que no tengo ningún control sobre. Para la posterior manipulación del objeto que quiero seguir trabajando con un unique_ptr en este objeto. Aquí hay un ejemplo:

#include <iostream>
#include <memory>

class Bla {
  public:
      Bla() { std::cout << "Constructor!\n"; }
      ~Bla() { std::cout << "Destructor!\n"; }
};

Bla GetBla() {
  Bla bla;
  return std::move(bla);
}

int main() {
  auto bla = std::make_unique<Bla>(GetBla());
}

El ejemplo produce el siguiente resultado:

Constructor!
Destructor!
Destructor!
Destructor!

¿Por qué es el destructor de Bla llama 3 veces aquí? Es la forma en que se crea la unique_prt correcta?

rustyx:

De hecho, existen 3 veces que una instancia de Blase construye.

Bla GetBla() {
  Bla bla;    // 1st construction
  return std::move(bla); // 2nd construction (return by copy)
}

No regrese por el movimiento. Retribución justa bla, en la mayoría de los casos se elide la copia.

  auto bla = std::make_unique<Bla>(GetBla());  // 3rd construction - Bla copy construction

Tenga en cuenta que make_unique<Bla>siempre se construye una nueva instancia. En este caso, ya que estás pasando a otra instancia, se hace copia de la construcción.

Un indicio de que la construcción se lleva a cabo la copia es que el constructor por defecto se invoca sólo una vez, mientras que el destructor se invoca 3 veces. Eso es debido a que en los otros 2 casos se invoca la copia implícito (o mover) constructor ( Bla::Bla(Bla const&)).