• Classes

As classes habilitam ao programador modelar objetos que têm atributos. Classes podem ter funções membros, que são conhecidas como métodos.
A implementação de uma classe começa com a palavra chave class, o corpo da classe é determinado com chaves e ao fim o ponto e virgula como em uma struct.

As classes podem conter também 2 novos rotulos. Public: e Private: que são chamados de especificadores de acesso a membros.
Qualquer dado ou função que for especificado após ao public: são acessíveis em qualquer lugar que o programa tenha acesso ao objeto desta classe.
Qualquer dado ou função que for especificado após ao private: só serão acessíveis somente na classe ou por funções membros da classe.

Exemplo de declaração:

class time {
public:
  void imprimir();

private:
  int hora;
  int minuto;
  int segundo;
};

Dentro de uma classe podemos ter também uma função construtor. Essa função recebe o mesmo nome da classe, e ela é executada quando a classe é instanciada.
Geralmente ela é usada para iniciar valores. Observação: Um construtor não pode retornar valor, isso é um erro de sintaxe.

Exemplo de construtor para a classe time:
class time {
public:
  time();
  void imprimir();

private:
  int hora;
  int minuto;
  int segundo;
};

time::time()
{
  hora = 0;
  minuto = 0;
  segundo = 0;
}

Observe que para escrever a função construtor de time usamos o operador de resolução de escopo (::). Toda função de uma classe deve ser definida. O operador serve para diferenciar classe de nomes diferentes com funções de nomes iguais.

Assim sendo, podemos inserir várias outras funções no corpo da classe.

class time {
public:
  time();
  void imprimir();
  void criar();

private:
  int hora;
  int minuto;
  int segundo;
};

time::time()
{
  hora = 0;
  minuto = 0;
  segundo = 0;
}

void time::imprimir()
{
   cout << hora << ":" << minuto << ":" << segundo;
}

void time::criar()
{
  hora = 10;
  minuto = 20;
  segundo = 04;
}

As classes são instanciadas no programa como estruturas, confira um exemplo completo.

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

class calculadora {
public:
   calculadora();        // construtor ( sem retorno, sem void )
   int soma( int, int );
   int sub ( int, int );
   int mult( int, int );
   int div ( int, int );

private:
   int num1;    // fora dos membros não é possivel ter acesso ao esses dados
   int num2;
};

calculadora::calculadora()    // apenas para exemplo de inicialização de variáveis
{
   num1 = num2 = 0;
}

calculadora::soma( int a, int b )
{
   return a + b;
}

calculadora::sub ( int a, int b )
{
   return a - b;
}

calculadora::mult( int a, int b )
{
   return a * b;
}

calculadora::div ( int a, int b )
{
   return a / b;
}

int main()
{
   calculadora calc; // instanciando

   cout << calc.soma(10, 5) << endl;
   cout << calc.sub (10, 5) << endl;
   cout << calc.mult(10, 5) << endl;
   cout << calc.div (10, 5) << endl;

   std::cin;
   return 0;
}

Dados e membros de uma classes pertencem ao escopo da classe. As funções não membro são definidas como escopo do arquivo.
Dentro do escopo da classe, os membros são acessiveis imediatamente por todas as funções da classes. Fora da classe, os membros publicos podem ser acessíveis ou referenciados pelo handles ponto, ao qual já vimos no exemplo, ou pela seta -> no caso de ponteiros para classes.

As funções membro de uma classe pode ser sobrecarregadas, mas apenas por outras funções. As variáveis definidas em uma função membro tem escopo de função, são conhecidas somente na função atual. As vezes as funções de classes podem ter o mesmo nome de variáveis que as variáveis da classe, neste caso, as váriaveis da classe são acessíveis com o operador de resolução de escopo ( :: );

#include <iostream>
using std::endl;

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

void teste::imprime()
{
  std::cout << a << endl;
}

int main()
{
  teste classe;                           // instancia da classe
  teste &referencia = classe;        // referencia da classe
  teste *ponteiro = &referencia;   // ponteiro para a classe

  classe.a = 10;
  classe.imprime();

  referencia.a = 20;
  referencia.imprime();

  ponteiro->a = 30;
  ponteiro->imprime();

  std::cin;
  return 0;
}