Orientação a Objetos em C++

Definições	Copy Constructor	Membros Static
Classes	Outros Exemplos Usando Construtores	Herança
Construtores	Destrutores	Funções Virtuais e Polimorfismo

Definições

Classes: modelos para a criação de objetos;
Atributos: dados dos objetos;
Métodos: rotinas que acessam os dados da classe;
Objetos: instâncias de uma classe.

Classes

C++ possibilita ao desenvolvedor separar a interface de uma classe de sua implementação.
Esta padronização, além de facilitar a modificação dos programas, permite com que qualquer cliente que queira usar uma determinada classe apenas inclua a sua interface, não expondo o acesso direto ao código-fonte.

Uma interface em C++ (ou assinatura da classe) é definida por um arquivo de cabeçalho (arquivo.h ou arquivo.hpp), como demonstrado abaixo:

#include <iostream>
using namespace std;

class Conta
{
int numero;    // São atributos
string nome;    // privados por
float saldo;    // default
public:
void inicializa(string n, float s);
void deposita(float valor);
void consulta();
int saque(float valor);
};

Já a implementação da classe é definida por um arquivo CPP. Cabe lembrar que deve-se incluir a interface no início do arquivo, conforme a descrição a seguir:

#include "conta.h"

void Conta::inicializa(string n, float s)
{
nome = n;
saldo = s;
if (saldo < 0)
cout << "Erro na Criação da Conta!!!" << endl;
}

void Conta::deposita(float valor)
{
saldo = saldo + valor;
}

void Conta::consulta()
{
cout << "Cliente: " << nome << endl;
cout << "Saldo Atual: " << saldo << endl;
cout << "Numero da Conta: " << numero << endl;
}

int Conta::saque(float valor)
{
if (saldo < valor)
return 0;
else
{
saldo = saldo - valor;
return 1;
}
}

E, fazendo o uso da classe Conta, no programa principal:

#include "conta.h"

void main()
{
Conta MinhaConta;
Conta *OutraConta;

MinhaConta.saldo = 10; // ERRO!!!

MinhaConta.inicializa("Fulano", 10.25);
OutraConta->inicializa("Beltrano", 220.00);

MinhaConta.deposita(12.75);
MinhaConta.consulta();
MinhaConta.saque(15.00);
MinhaConta.consulta();

OutraConta->consulta();
}

Exemplo de uso de construtores (conta.h    conta.cpp    cpessoa.h    cpessoa.cpp   main.cpp)

Construtores

Quando um objeto de uma classe é criado, seus membros podem ser inicializados através de um método construtor. Tais métodos, quando definidos, devem possuir o mesmo nome da classe.

Construtores servem para inicializar dados de um objeto. Uma classe também pode ter vários construtores diferentes implementados. Além disso, eles só podem ser chamados usando o comando new ou na declaração de um objeto de uma certa classe.

CPessoa P1;
CPessoa *P2;
P2 = new CPessoa(); // tanto um como o outro
P2 = new CPessoa; // estão corretos e funcionam

Caso a classe não define um construtor, então o compilador define um construtor default sem parâmetros. Assim, ao declarar um objeto, não se coloca parênteses após o nome do mesmo.

No momento que um construtor é definido, o compilador não define mais um construtor default, exigindo do desenvolvedor a declaração deste.

class CPessoa
{
string nome;
public:
CPessoa(); // construtor default definido pelo usuário
CPessoa(string n);
};

Atenção: Não é possível chamar uma construtora de dentro de outra.

Exemplo de uso de construtores (construtores.h construtores.cpp main.cpp)

Copy Constructor

Sempre que se define uma classe, automaticamente, o compilador define um construtor capaz de copiar os dados de um objeto para outro que esteja sendo declarado. Sua declaração é:

CPessoa P3(P1);

ou equivalente:

CPessoa P3 = P1;

Outros Exemplos Usando Construtores

CConta.h:

class CConta
{
int numero;
public:
CConta();
CConta(int a);
};

CConta.cpp:

#include "CConta.h"
CConta::CConta(int a)
{
numero = a;
};

main.cpp:

#include "CConta.h"
void main()
{
CConta C;
CConta C1(1001);
CConta *C2;
C2 = new CConta();
CConta *C3;
C3 = new CConta[4](); // Cria 4 objetos, chamando a construtora padrão

CConta C4[3]; // Cria 3 objetos, chamando a construtora padrão

CConta *C5;
C5 = new CConta[3](10); // ERRO !!! Não funciona

CConta C6[3](); // ERRO !!! Não funciona
}

Destrutores

O destrutor é chamado quando um objeto deixa de existir (caso esta não seja dinâmica). Ele deve ser chamado após todos os comandos da rotina, por intermédio do comando delete.

delete C2;
delete C3[];

O destrutor não tem parâmetros e não tem tipo de retorno. Sua declaração na assinatura da classe é feita da seguinte forma:

class CPessoa
{
CPessoa(); // construtora
~CPessoa(); // destrutora - Mesmo nome da classe, precedido do caractere ~ (til)
}

Apenas pode existir um destrutor por classe. Sua implementação no arquivo CPP é assim descrita:

CPessoa::~CPessoa()
{
// chamada quando delete é utilizado
}

Membros Static

Atributos static são variáveis que não são duplicadas nos objetos da classe. Eles são atributos da própria classe. Tais variáveis podem ser utilizadas, por exemplo, para manter um contador de objetos de uma classe.

Já métodos static são funções membro que podem ser evocados pelo programa-cliente que os incluiu sem que haja um objeto de classe.funções auxiliares, como as de Matemática.

Métodos static não conseguem acessar diretamente variáveis ou métodos que não sejam static, pois eles pertencem a classe e não saberiam de qual instância utilizar.

Os atributos desta natureza precisam ser inicializados neste formato:

int classe::constante = valor;

sendo que esta declaração deve ser efetuada fora de qualquer classe ou método.

Exemplo de uso de membros static (trigonometria.h trigonometria.cpp main.cpp)