Son diferentes.

new y delete te dan un control muy preciso sobre el ciclo de vida de los objetos... pero ese control tiene un precio a pagar y es que vas a tener que estar muy pendiente para evitar lagunas de memoria.

los smart pointers son una característica bastante interesante de la stl. Te permite relajarte en la gestión de la memoria dinámica a costa de perder cierto control sobre el ciclo de vida de los objetos. Yo, a título personal, únicamente soy partidario de usar unique_ptr, ya que con shared_ptr el concepto de "ciclo de vida" queda demasiado difuso.

También recordar que shared_ptr puede provocar lagunas de memoria si creas relaciones circulares... y usar weak_ptr es, a veces, un coñazo

Este ejemplo te demostrará que un diseño incorrecto con smart pointers puede acabar con lagunas de memoria:

#include <iostream>
#include <memory>
 
class Nodo
{
    static int id;
 
  public:
    Nodo( )
      : _id( id++ )
    {  std::cout << "Nodo " << id << " creado" << std::endl; }
 
    ~Nodo( )
    { std::cout << "Nodo " << id << " destruido" << std::endl; }
 
    std::shared_ptr< Nodo > puntero;
 
  private:
 
    int _id;
};
 
int Nodo::id = 0;
 
void func( )
{
    std::shared_ptr< Nodo > nodo1 = std::make_shared< Nodo >( );
    std::shared_ptr< Nodo > nodo2 = std::make_shared< Nodo >( );
    std::shared_ptr< Nodo > nodo3 = std::make_shared< Nodo >( );
 
    nodo1->puntero = nodo2;
    nodo2->puntero = nodo1;
}
 
int main( )
{
  std::cout << "Llamada a func" << std::endl;
 
  func( );
 
  std::cout << "Y la llamada a los destructores de nodo1 y nodo2?" << std::endl;
}

Efectivamente, un shared_ptr está diseñado para borrar su contenido cuando éste ya no esté referenciado... el problema es que, si se crean referencias circulares, se crea una dependencia mutua que impide que los elementos se borren.