Introducción
C ++ trata las variables de tipos definidos por el usuario con semántica de valores . Esto significa que los objetos se copian implícitamente en varios contextos, y debemos entender lo que realmente significa "copiar un objeto".
Permítanos considerar un ejemplo sencillo:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(Si está desconcertado por la name(name), age(age)parte, esto se llama una lista de inicializador de miembros ).
Funciones especiales para miembros
¿Qué significa copiar un personobjeto? La mainfunción muestra dos escenarios de copia distintos. La inicialización person b(a);es realizada por el constructor de la copia . Su trabajo es construir un objeto nuevo basado en el estado de un objeto existente. La asignación la b = arealiza el operador de asignación de copia . Su trabajo es generalmente un poco más complicado, porque el objeto de destino ya está en algún estado válido que necesita ser tratado.
Como no declaramos a nosotros ni el constructor de la copia ni el operador de asignación (ni el destructor), estos se definen implícitamente para nosotros. Cita del estándar:
El constructor de [...] copia y el operador de asignación de copia, [...] y el destructor son funciones miembro especiales. [ Nota : La implementación declarará implícitamente estas funciones miembro para algunos tipos de clase cuando el programa no las declare explícitamente.
La implementación los definirá implícitamente si se usan. [...] nota final ] [n3126.pdf sección 12 §1]
Por defecto, copiar un objeto significa copiar sus miembros:
El constructor de copia implícitamente definido para una clase X sin unión realiza una copia miembro de sus subobjetos. [n3126.pdf sección 12.8 §16]
El operador de asignación de copia definido implícitamente para una clase X no sindicalizada realiza la asignación de copia miembro de sus subobjetos. [n3126.pdf sección 12.8 §30]
Definiciones implícitas
Las funciones de miembro especiales definidas implícitamente para persontener este aspecto:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
La copia a nivel de miembro es exactamente lo que queremos en este caso:
namey agese copian, por lo que obtenemos un objeto autónomo e independiente person. El destructor definido implícitamente siempre está vacío. Esto también está bien en este caso ya que no adquirimos ningún recurso en el constructor. Los destructores de los miembros se invocan implícitamente después de que el persondestructor finaliza:
Después de ejecutar el cuerpo del destructor y destruir los objetos automáticos asignados dentro del cuerpo, un destructor para la clase X llama a los destructores para los miembros directos de X [n3126.pdf 12.4 §6]
Administrar recursos
Entonces, ¿cuándo debemos declarar explícitamente esas funciones miembro especiales? Cuando nuestra clase gestiona un recurso , es decir, cuando un objeto de la clase es responsable de ese recurso. Eso generalmente significa que el recurso se adquiere en el constructor (o se pasa al constructor) y se libera en el destructor.
Regresemos en el tiempo a C ++ preestándar. No existía tal cosa std::string, y los programadores estaban enamorados de los punteros. La personclase podría haberse visto así:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
Incluso hoy, la gente todavía escribe clases en este estilo y se mete en problemas: " ¡Empujé a una persona a un vector y ahora tengo errores de memoria locos! " Recuerde que, de forma predeterminada, copiar un objeto significa copiar a sus miembros, pero copiar al namemiembro simplemente copia un puntero, no el conjunto de caracteres al que apunta. Esto tiene varios efectos desagradables:
- Los cambios a través de
ase pueden observar a través de b.
- Una vez que
bse destruye, a.namees un puntero que cuelga.
- Si
ase destruye, eliminar el puntero colgante produce un comportamiento indefinido .
- Dado que la asignación no tiene en cuenta lo que
nameseñalaba antes de la asignación, tarde o temprano obtendrá pérdidas de memoria por todas partes.
Definiciones explícitas
Como la copia a nivel de miembro no tiene el efecto deseado, debemos definir el constructor de copia y el operador de asignación de copia explícitamente para hacer copias profundas de la matriz de caracteres:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
Tenga en cuenta la diferencia entre inicialización y asignación: debemos derribar el estado anterior antes de asignar a namepara evitar pérdidas de memoria. Además, tenemos que protegernos contra la autoasignación del formulario x = x. Sin esa verificación, delete[] namesería eliminar la matriz que contiene la fuente de la cadena, porque cuando se escribe x = x, tanto this->namey that.namecontener el mismo puntero.
Seguridad de excepción
Desafortunadamente, esta solución fallará si new char[...]arroja una excepción debido al agotamiento de la memoria. Una posible solución es introducir una variable local y reordenar las declaraciones:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
Esto también se encarga de la autoasignación sin una verificación explícita. Una solución aún más robusta para este problema es el modismo de copiar e intercambiar , pero no entraré aquí en los detalles de seguridad de excepción. Solo mencioné excepciones para hacer el siguiente punto: Escribir clases que administren recursos es difícil.
Recursos no cobrables
Algunos recursos no pueden o no deben copiarse, como los identificadores de archivos o mutexes. En ese caso, simplemente declare el constructor de copia y el operador de asignación de copia como privatesin dar una definición:
private:
person(const person& that);
person& operator=(const person& that);
Alternativamente, puede heredarlos boost::noncopyableo declararlos como eliminados (en C ++ 11 y superior):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
La regla de tres
A veces necesita implementar una clase que gestione un recurso. (Nunca administre múltiples recursos en una sola clase, esto solo provocará dolor). En ese caso, recuerde la regla de tres :
Si necesita declarar explícitamente el destructor, el constructor de copia o el operador de asignación de copia usted mismo, probablemente deba declarar explícitamente los tres.
(Desafortunadamente, esta "regla" no es aplicada por el estándar C ++ ni por ningún compilador que conozca).
La regla de cinco
A partir de C ++ 11, un objeto tiene 2 funciones miembro especiales adicionales: el constructor de movimiento y la asignación de movimiento. La regla de cinco estados para implementar estas funciones también.
Un ejemplo con las firmas:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
La regla de cero
La regla de 3/5 también se conoce como la regla de 0/3/5. La parte cero de la regla establece que se le permite no escribir ninguna de las funciones especiales del miembro al crear su clase.
Consejo
La mayoría de las veces, no necesita administrar un recurso usted mismo, porque una clase existente como std::stringya lo hace por usted. Simplemente compare el código simple usando un std::stringmiembro con la alternativa enrevesada y propensa a errores usando a char*y debería estar convencido. Siempre y cuando se mantenga alejado de los miembros de puntero sin procesar, es poco probable que la regla de tres se refiera a su propio código.
c++-faqetiqueta wiki antes de votar para cerrar .