• Construtores e Destruidores

Abordando novamente os construtores, vamos ver que eles também podem receber valores, como funções normalmente. Só que para isso, temos que usar argumentos default. É considerado uma boa prática de programação e engenharia de softwere assegurar que um objeto seje completamente inicializado antes que o código cliente invoque as funções da classe.

Os membros de dados de uma classe não podem ser inicializados na definição da classe!
Tentar declarar um tipo de retorno para um construtor é um erro de sintaxe.

Exemplo simples de um construtor usando default:

#include <iostream>
using std::endl;

class teste {
public:
   teste( int = 0 );
   int a;
   void imprime();
};

teste::teste( int b ) // aqui b nao é igual a zero, soh na definição
{
   a = b;
}
void teste::imprime()
{
   std::cout << "valor: "<< a << endl;
}

int main()
{
   teste c;
   c.imprime();

   teste c2(10);    // outra instancia
   c2.imprime();    // a = 10

   std::cin;
   return 0;
}

Um destrutor é uma função membro especial de uma classe. O nome do destrutor é formado pelo caracter til ( ~ )seguido pelo nome da classe. O destruidor de uma classe é chamado quando um objeto é destruido, ele executa uma faxina na memória onde se situava o objeto.

O destruidor não recebe nenhum argumento e não retorna valor, cada classe pode ter somente um destruidor e também não é possivel sobrecarregar destruidores.

Tanto construtor como destuidor são chamados automaticamentes pela classe.
Objetos podem ser decladados como static, por isso, os construtores são chamados apenas uma vez nesse caso.
Os destruidores são executados quando main termina ou exit é chamada.. veremos mais a frente.

Agora um exemplo de construtore e destruidores... execute o programa e verifique as ordens de chamada. Muito interessante

#include <iostream>
using std::cout;
using std::endl;

class criar_destruir {
public:
  criar_destruir( int );   // construtor
  ~criar_destruir();      // destrutor
  int n;
};

criar_destruir::criar_destruir( int num )
{
  n = num;
  cout << "Objeto "<< n <<" criado" << endl;
}

criar_destruir::~criar_destruir()
{
  cout << "Objeto "<< n <<" DESTRUIDO " << endl;
}

void outros();   // prototipo para mais objetos do exemplo

// vamos agora criar um objeto global
criar_destruir n1( 1 );

int main()
{
  criar_destruir n2( 2 );
  static criar_destruir n3( 3 );

  outros();

  criar_destruir n4( 4 );

  std::cin;
  return 0;
}

void outros()
{
  criar_destruir n5( 5 );
  static criar_destruir n6( 6 );
  criar_destruir n7( 7 );
}

- Não se esqueça que:

Qualquer construtor que é chamado com um argumento pode ser usado pelo compilador para executar uma conversão implícita, na qual o tipo recebido pelo construtor é convertido em um objeto da classe na qual o construtor está definido. A conversão é automatica e o programador não usar um operador de coerção.