Constructores y Destructores

Constructores:
En programación orientada a objetos (POO), un constructor es una subrutina cuya misión es
inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo
objeto.

Se utiliza para crear tablas de clases virtuales y poder así desarrollar el polimorfismo, una de las
herramientas de la programación orientada a objetos. Al utilizar un constructor,
el compilador determina cuál de los objetos va a responder al mensaje (virtual) que hemos creado.
Tiene un tipo de acceso, un nombre y un paréntesis.

Ejemplo:

#include <iostream.h>
class pareja
{
public:
//Constructor
pareja(int a2, int b2);
//Funciones miembros de la clase "pareja"
void Lee(int &a2, int &b2);
void Guardar(int a2, int b2);
private:
//Datos miembros de la clase "pareja"
int a, b;
}
pareja::pareja(int a2, int b2)
{
a = a2;
b = b2;
}
void pareja::Lee(int &a2, int &b2)
{
a2 = a;
b2 = b;
}
void pareja::Guarda(int a2, int b2)
{
a = a2;
b = b2;
}
int main(int argc, char *argv[])
{
pareja par1(12, 32);
int x, y;
par1.Lee(x, y);
cout << "Valor de par1.a: " << x <<endl;
cout << "Valor de par2.b: " << x <<endl;
return 0;
}
Destructores:
Un destructor en programación orientada a objetos es una función miembro especial llamadas
automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas
explícitamente por el programador. Sus principales cometidos son:

 Liberar los recursos computacionales que el objeto de dicha clase haya adquirido en su
tiempo de ejecución al expirar éste.
 Quitar los vínculos que pudiesen tener otros recursos u objetos con éste.

Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito
en el que está declarado el objeto.

Ejemplo:

#include <iostream>
#include <string>

class foo
{
public:

foo( void )
{
print( "foo()" );
}

~foo( void )
{
print( "~foo()" );
}

void print( std::string const& text )

{
std::cout << static_cast< void* >( this ) << " : " << text << std::endl;
}

/*
Deshabilitado el contructor de copia y el operador de asignación al hacerlos
privados
*/
private:

foo( foo const& );

 foo& operator = ( foo const& );
};

int main( void )

{
foo array[ 3 ];
/*
Cuanto la 'main' termina, el destructor es invocado para cada elemento de 'array'.
La primera instancia creada es la última en ser destruída.
*/
}