Desde elaumentar la documentación de la biblioteca Leo esto:

Conceptualmente, se considera que los punteros inteligentes poseen el objeto apuntado y, por lo tanto, son responsables de la eliminación del objeto cuando ya no es necesario.

Tengo un problema muy simple: quiero usar RAII para los atributos de puntero de una clase que se puede copiar y asignar.

Las operaciones de copia y asignación deben ser profundas: cada objeto debe tener su propia copia de los datos reales. Además, RTTI debe estar disponible para los atributos (su tipo también puede determinarse en tiempo de ejecución).

¿Debería estar buscando una implementación de un puntero inteligente que se pueda copiar (los datos son pequeños, por lo que no necesitoCopiar en escrito punteros), o delego la operación de copia a los constructores de copia de mis objetos como se muestra enesta respuesta?

¿Qué puntero inteligente elijo para RAII simple de una clase que se puede copiar y asignar? (Estoy pensando que unique_ptr con operaciones de copia / asignación delegadas al constructor de copia de clase y al operador de asignación harían una elección adecuada, pero no estoy seguro)

Aquí está unpseudocódigo para el problema de usar punteros en bruto, es solo una descripción del problema, no un código C ++ en ejecución:

// Operation interface
class ModelOperation
{
    public: 
        virtual void operate = (); 
};

// Implementation of an operation called Special 
class SpecialModelOperation
:
    public ModelOperation
{
    private:
        // Private attributes are present here in a real implementation. 

    public: 

        // Implement operation
        void operate () {}; 
};

// All operations conform to ModelOperation interface
// These are possible operation names: 
// class MoreSpecialOperation; 
// class DifferentOperation; 

// Concrete model with different operations
class MyModel 
{
    private: 
        ModelOperation* firstOperation_; 
        ModelOperation* secondOperation_;  

    public:

        MyModel()
            : 
                firstOperation_(0), 
                secondOperation_(0)
        {
            // Forgetting about run-time type definition from input files here.
            firstOperation_  = new MoreSpecialOperation(); 
            secondOperation_ = new DifferentOperation(); 
        }

        void operate()
        {
            firstOperation_->operate(); 
            secondOperation_->operate();
        }

        ~MyModel() 
        {
            delete firstOperation_; 
            firstOperation_ = 0; 

            delete secondOperation_; 
            secondOperation_ = 0; 
        }
};

int main()
{

    MyModel modelOne; 

    // Some internal scope
    {
        // I want modelTwo to have its own set of copied, not referenced 
        // operations, and at the same time I need RAII to for the operations, 
        // deleting them automatically as soon as it goes out of scope. 
        // This saves me from writing destructors for different concrete models.  
        MyModel modelTwo (modelOne); 
    }


    return 0;
}