c++ - pointer - shared_ptr reference

C++ 11 Al borrar shared_ptr, ¿debo usar reset o configurar nullptr?

Question

Tengo una pregunta sobre las mejores prácticas de C ++ 11. Al borrar un shared_ptr, ¿debo usar la función reset() sin parámetros, o debo configurar shared_ptr en nullptr ? Por ejemplo:

std::shared_ptr<std::string> foo(new std::string("foo"));
foo.reset();
foo = nullptr;

¿Hay alguna diferencia real, o hay ventajas / desventajas en cualquiera de los enfoques?

Answer 1

¿Hay alguna diferencia real, o hay ventajas / desventajas en cualquiera de los enfoques?

Las dos alternativas son absolutamente equivalentes, en el sentido de que la segunda forma ( foo = nullptr ) se define en términos de la primera. Según el párrafo 20.7.1.2.3 / 8-10 de la norma C ++ 11:

 unique_ptr& operator=(nullptr_t) noexcept;

8 efectos : reset() .

9 Postcondición : get() == nullptr

10 Devoluciones : *this .

Por lo tanto, simplemente elige el que te aclare lo más posible . Personalmente, prefiero:

foo = nullptr;

Porque hace más evidente que queremos que el puntero sea nulo. Sin embargo, como un consejo general, intente minimizar las situaciones en las que necesita restablecer explícitamente un puntero inteligente.

Además, en lugar de usar new :

std::shared_ptr<std::string> foo(new std::string("foo"));

Considere usar std::make_shared() cuando sea posible:

auto foo = std::make_shared<std::string>("foo");

Answer 2

Generalmente, los punteros inteligentes pueden manejarse solos. Pero si necesita una solución, el reset() es, en mi opinión, su mejor apuesta.

Answer 3

Preferiría reset() ya que señala la intención. Sin embargo, intente escribir su código de manera que no necesite borrar explícitamente un shared_ptr<> , es decir, asegúrese de que shared_ptr<> fuera del alcance cuando de lo contrario lo shared_ptr<> .

Answer 4

Tienen un poco diferente si utiliza https://godbolt.org/ para verificar
utilizando gcc (7.2)
foo.reset(); genera código de ensamblaje

  lea rax, [rbp-32]
  mov rdi, rax
  call std::__shared_ptr<int, (__gnu_cxx::_Lock_policy)2>::reset()

sin embargo, foo = nullptr; genera

  lea rax, [rbp-16]
  mov esi, 0
  mov rdi, rax
  call std::shared_ptr<int>::shared_ptr(decltype(nullptr))
  lea rdx, [rbp-16]
  lea rax, [rbp-32]
  mov rsi, rdx
  mov rdi, rax
  call std::shared_ptr<int>::operator=(std::shared_ptr<int>&&)
  lea rax, [rbp-16]
  mov rdi, rax
  call std::shared_ptr<int>::~shared_ptr()

Crea un puntero compartido con nullptr, asigna el objeto recién creado a la variable y llama al destructor a la cadena de destino.

Como no sé cómo comprobar qué sucedió en la función reset (). No se puede ver cuál es más rápido.