0
Destructores
Los destructores son funciones miembro especiales que sirven para eliminar un objeto de una determinada clase. El destructor realizará procesos necesarios cuando un objeto termine su ámbito temporal, por ejemplo liberando la memoria dinámica utilizada por dicho objeto o liberando recursos usados, como ficheros, dispositivos, etc.
Al igual que los constructores, los destructores también tienen algunas características especiales:
-También tienen el mismo nombre que la clase a la que pertenecen, pero tienen el símbolo ˜ delante.
-No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
-No tienen parámetros.
-No pueden ser heredados.
-Deben ser públicos, no tendría ningún sentido declarar un destructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
-No pueden ser sobrecargados, lo cual es lógico, puesto que no tienen valor de retorno ni parámetros, no hay posibilidad de sobrecarga.
Cuando se define un destructor para una clase, éste es llamado automáticamente cuando se abandona el ámbito en el que fue definido. Esto es así salvo cuando el objeto fue creado dinámicamente con el operador new, ya que en ese caso, cuando es necesario eliminarlo, hay que hacerlo explícitamente usando el operador delete.
En general, será necesario definir un destructor cuando nuestra clase tenga datos miembro de tipo puntero, aunque esto no es una regla estricta.
Ejemplo:
|
#include <iostream>
#include <cstring>
using namespace std;
class cadena {
public:
cadena(); // Constructor por defecto
cadena(const char *c); // Constructor desde cadena c
cadena(int n); // Constructor de cadena de n caracteres
cadena(const cadena &); // Constructor copia
~cadena(); // Destructor
void Asignar(const char *dest);
char *Leer(char *c);
private:
char *cad; // Puntero a char: cadena de caracteres
};
cadena::cadena() : cad(NULL) {}
cadena::cadena(const char *c) {
cad = new char[strlen(c)+1];// Reserva memoria para cadena
stry(cad, c); // Almacena la cadena
}
cadena::cadena(int n) {
cad = new char[n+1]; // Reserva memoria para n caracteres
cad[0] = 0; // Cadena vacía
}
cadena::cadena(const cadena &Cad) {
// Reservamos memoria para la nueva y la almacenamos
cad = new char[strlen(Cad.cad)+1];
// Reserva memoria para cadena
stry(cad, Cad.cad); // Almacena la cadena
}
cadena::~cadena() {
delete[] cad; // Libera la memoria reservada a cad
}
void cadena::Asignar(const char *dest) {
// Eliminamos la cadena actual:
delete[] cad;
// Reservamos memoria para la nueva y la almacenamos
cad = new char[strlen(dest)+1];
// Reserva memoria para la cadena
stry(cad, dest); // Almacena la cadena
}
char *cadena::Leer(char *c) {
stry(c, cad);
return c;
}
int main() {
cadena Cadena1("Cadena de prueba");
cadena Cadena2(Cadena1); // Cadena2 es copia de Cadena1
cadena *Cadena3; // Cadena3 es un puntero
char c[256];
// Modificamos Cadena1:
Cadena1.Asignar("Otra cadena diferente");
// Creamos Cadena3:
Cadena3 = new cadena("Cadena de prueba nº 3");
// Ver resultados
cout << "Cadena 1: " << Cadena1.Leer(c) << endl;
cout << "Cadena 2: " << Cadena2.Leer(c) << endl;
cout << "Cadena 3: " << Cadena3->Leer(c) << endl;
delete Cadena3; // Destruir Cadena3.
// Cadena1 y Cadena2 se destruyen automáticamente
return 0;
} |
Ejecutar este código en codepad.
Voy a hacer varias observaciones sobre este programa:
1-Hemos implementado un constructor copia. Esto es necesario porque una simple asignación entre los datos miembro "cad" no copiaría la cadena de un objeto a otro, sino únicamente los punteros.
Por ejemplo, si definimos el constructor copia como:
| cadena::cadena(const cadena &Cad) {
cad = Cad.cad;
}
|
en lugar de cómo lo hacemos en el ejemplo, lo que estaríamos copiando sería el valor del puntero cad, con lo cual, ambos punteros estarían apuntando a la misma posición de memoria. Esto es desastroso, y no simplemente porque los cambios en una cadena afectan a las dos, sino porque al abandonar el programa se intenta liberar automáticamente la misma memoria dos veces.
Lo que realmente pretendemos al asignar cadenas es crear una nueva cadena que sea copia de la cadena antigua. Esto es lo que hacemos con el constructor copia del ejemplo, y es lo que haremos más adelante, y con más elegancia, sobrecargando el operador de asignación.
La definición del constructor copia que hemos creado en este último ejemplo es la equivalente a la del constructor copia por defecto.
2-La función Leer, que usamos para obtener el valor de la cadena almacenada, no devuelve un puntero a la cadena, sino una copia de la cadena. Esto está de acuerdo con las recomendaciones sobre la programación orientada a objetos, que aconsejan que los datos almacenados en una clase no sean accesibles directamente desde fuera de ella, sino únicamente a través de las funciones creadas al efecto. Además, el miembro cad es privado, y por lo tanto debe ser inaccesible desde fuera de la clase. Más adelante veremos cómo se puede conseguir mantener la seguridad sin crear más datos miembro.
3-La Cadena3 debe ser destruida implícitamente usando el operador delete, que a su vez invoca al destructor de la clase. Esto es así porque Cadena3 es un puntero, y la memoria que se usa en el objeto al que apunta no se libera automáticamente al destruirse el puntero Cadena3.
Ir al Principio
Comentarios