C++: sobre gestión de memoria

Question

Soy un poco nuevo en C++ y he estado haciendo programación en Obj-C y Java hasta ahora.

decir que tengo una clase:

class Person { 

private: 
    Wife *current_wife; 
    //..... 
}; 

Así OBV I necesidad de implementar un método de selección para cambiar la variable de instancia esposa.

De esta manera:

Person::SetCurrentWife (Wife *new_wife) { 

    current_wife = new_wife; 
} 

Eso sería una copia shalllow.

Así que en algún lugar del bucle principal o algo que llamo:

Person *some_person = new Person(); 
... 
Wife *wife = new Wife(); 
some_person->SetCurrentWife(wife); 

Así que estoy confundido: ¿habrá una pérdida de memoria en esta lista? ¿Debo eliminar el objeto esposa aquí o en el destructor de la persona? En Obj-C liberaría a la esposa actual y luego enviaría un mensaje de retención a la esposa del objeto anterior, pero ¿cuál es la forma correcta de hacer métodos setter en C++?

Answer 1

Debe usar un puntero inteligente.

Si usa el puntero regular, ¡tenga cuidado!

Debe delete el miembro antiguo current_wife tanto en el destructor como en el método set. Configurar una nueva esposa dará lugar a la pérdida de memoria de la anterior, ya que el puntero a esa memoria asignada se pierde (a menos que administre la memoria fuera de la clase - vea abajo).

Pero incluso si lo hace, debe asegurarse de que nadie fuera de la clase pueda eliminar el miembro. Debe decidir si la gestión de la memoria se deja a la clase o se envía al exterior de la clase, y se adhiere a ella.

Answer 2

punteros inteligentes pueden ayudarle a

using boost::shared_ptr; // or std::shared_ptr, or std::tr1::shared_ptr or something like this 
class Person { 

private: 
    shared_ptr<Wife> current_wife; 
    //..... 
}; 

Person::SetCurrentWife (shared_ptr<Wife> new_wife) { 

    current_wife = new_wife; 
} 

Y ahora no deberían eliminar cualquier mujer en absoluto.

shared_ptr<Person> some_person (new Person); 
... 
shared_ptr<Wife> wife (new Wife); 
some_person->SetCurrentWife(wife); 

Answer 3

Depende de lo que estés tratando de hacer. En primer lugar, como Kerrek SB tiene comentó, no desea utilizar punteros si la semántica del valor puede ser aplicada: si Wife es copiable y asignable, no hay casi ninguna razón para asignarlo dinámicamente. En este caso, sin embargo, supongo que Wife deriva de Person (aunque quizás un decorador de Person sería más apropiado, ya que el hecho de que un determinado Person ISA Wife puede cambiar con el tiempo), que podría ser incluso tipos derivados desde Wife (y que Person::current_wife pueden querer tener uno de estos), y que, de hecho, Wife tiene identidad; no desea copias de la misma esposa en todo el lugar.

Si este es el caso, entonces realmente tiene que definir un protocolo para las interacciones de otras clases con Wife.Normalmente, el tiempo de vida de Wife no dependerá de la Person que lo tiene (aunque si se trata de un decorador , que podría), por lo que debe Person acaba de celebrar un puntero a ella, como que has hecho. Lo más probable, el objeto Wife tendrá varias funciones el que el control — implícita o explícitamente — su vida útil: que pueda tener algo como:

void Wife::die() 
{ 
    // ... 
    delete this; 
} 

por ejemplo. En ese caso, sin embargo, quien esté casado con Wife tendrá tiene que ser informado, de modo que current_wife no apunta a un cónyuge muerto . Normalmente, se puede usar alguna variante del patrón de observador para esto. (Observe que tiene exactamente el mismo problema en Java;.. No lo hace quieren Person::current_wife para apuntar a un muerto Wife Así que usted todavía necesita una función Wife::die(), y el patrón de observador para notificar al cónyuge )

en casos como este (que en mi experiencia representan la gran mayoría de objetos asignados dinámicamente en C++), sobre la única diferencia entre C++ y Java es que C++ tiene una sintaxis especial para llamar la “ destructor ”; en Java, utiliza la función usual llamada sintaxis, y puede darle a la función el nombre que desee (aunque dispose parece ampliamente utilizado). La sintaxis especial permite al compilador generar código adicional para liberar la memoria, pero todas las demás actividades asociadas con el final de la duración del objeto todavía tienen que programarse (en el destructor, en C++ — aunque en este caso, es puede tener sentido poner algunos de ellos directamente en la función Wife::die ).