6  Classes

A partir deste ponto o ênfase será posto na construção de novos tipos.  De início construir-se-ão novos tipos relativamente simples e independentes uns dos outros.  Quando se iniciar o estudo da programação orientada por objectos ver-se-á como desenhar hierarquias de tipos e quais as suas aplicações na resolução de problemas de maior escala.

6.1  Introdução às classes

class Aluno {
  public:
    string nome;
    int número;
};

class nome_do_tipo {
    declaração_de_membros
};

6.1.1  Definição de classes

6.1.2  Selecção de membros

Aluno aluno1;

aluno1.nome = "Zacarias Zagalo";
aluno1.número = 123;

É importante perceber que cada variável do tipo Aluno possui as suas próprias variáveis membro.  Por exemplo:

Aluno aluno1;

aluno1.nome = "Zacarias Zagalo";
aluno1.número = 123;

Aluno aluno2;

aluno2.nome = "Xisto Ximenes";
aluno1.número = 321;
 

int número = 1000;
Aluno aluno1;

aluno1.nome = "Zacarias Zagalo";
aluno1.número = 123;

Aluno aluno2;

aluno2.nome = "Xisto Ximenes";
aluno1.número = 321;

* Em rigor, o ponto (.) é o operador de selecção de membro, como se pode ver na Tabela Precedência de operadores.

6.1.3  Alguma nomenclatura

Ver-se-há mais tarde que também podem existir funções ou procedimentos membro duma classe.  A essas funções ou procedimentos é comum chamar-se "métodos".  Por vezes também se ouve o termo "passar uma mensagem" em vez de invocar uma função membro.

Neste texto adoptar-se-ão apenas alguns destes termos.  Assim, uma classe é constituída por um conjunto de membros.  Estes membros podem ser funções (ou procedimentos) ou variáveis.  Os membros, ver-se-á mais tarde, podem ser de instância ou de classe, consoante cada instância da classe possua a sua própria cópia do membro ou exista apenas uma cópia partilhada entre todas as instâncias da classe.

6.1.4  Operações suportadas

Aluno aluno1;

aluno1.nome = "Zacarias Zagalo";
aluno1.número = 123;

Aluno aluno2;

aluno2 = aluno1;

6.1.5  Membros públicos e privados

6.2  Construção de classes

6.2.1  Os números racionais

Qualquer número racional pode ser representado por uma fracção, que é um par ordenado de números inteiros (n, d), em que n e d são os termos da fracção *.  Ao segundo termo dá-se o nome de denominador (é o que dá o nome à fracção) e ao primeiro numerador (diz a quantas fracções nos referimos).  Por exemplo, (3, 4) significa "três quartos".  Normalmente os racionais representam-se graficamente usando uma notação diferente: n/d.

Uma fracção n/d pode ou não representar um número racional: só se d for não nulo se pode dizer que a fracção corresponde a um número racional.  Outra questão importante tem a ver com unicidade de representação.  Será que fracções diferentes representam racionais diferentes?  A afirmação inversa é verdadeira (racionais diferentes têm forçosamente representações diferentes [ou n ou d o são]), mas -4/2, 2/-1 e -2/1 são fracções que correspondem a um único racional (por acaso também é um inteiro).  Para se obter uma representação única de cada racional, é necessário introduzir algumas restrições adicionais à fracções.

Em primeiro lugar, é necessário usar apenas o numerador ou o denominador para conter o sinal do número racional.  Como já se impôs uma restrição ao denominador, viz. d <> 0, é natural impor uma restrição adicional: d deve ser não negativo.  Assim, d > 0.  Mas é necessária uma restrição adicional.  Para que a representação seja única, é necessário que n e d não tenham qualquer divisor comum diferente de 1.  Ou seja, que mdc(|n|, d) = 1 (uma fracção com mdc(|n|, d) = 1 diz-se nos termos mínimos).

Assim, se n/d for uma fracção em que d > 0 e mdc(n, d) = 1, dir-se-á que a fracção está no formato canónico.

* Há representações alternativas [1].

Operações elementares

n₁/d₁ + n₂/d₂ = (n₁d₂ + n₂d₁)/(d₁d₂)
n₁/d₁ - n₂/d₂ = (n₁d₂ - n₂d₁)/(d₁d₂)
n₁/d₁ * n₂/d₂ = (n₁n₂)/(d₁d₂)
n₁/d₁ / n₂/d₂ = (n₁d₂)/(n₂d₁)

Adição e subtracção

n₁/d₁ + n₂/d₂ = (l * (n'₁d'₂ + n'₂d'₁))/(kd'₁d'₂)

k d'₁ = d₁
k d'₂ = d₂
l n'₁ = n₁
l n'₂ = n₂

1/10 + 1/15

1/10 + 1/15 = (l * (n'₁d'₂ + n'₂d'₁))/(k d'₁d'₂) = (5)/(5 * 6)

n₁/d₁ + n₂/d₂ = (l * (n'₁d'₂ + n'₂d'₁) / m)/((k / m) d'₁d'₂)

* Para simplificar, admite-se que mdc(0, 0) = 1.

Multiplicação

n₁/d₁ * n₂/d₂ = (n₁n₂)/(d₁d₂)

n₁/d₁ * n₂/d₂ = ((n₁ / k) (n₂ / l))/((d₁ / l) (d₂ / k))

Divisão

n₁/d₁ / n₂/d₂ = (n₁d₂)/(n₂d₁)

Operações de igualdade e desigualdade

Operações relacionais

n₁/d₁ > n₂/d₂ <=> n₁d₂ > n₂d₁

Podem-se reduzir os valores a comparar a

n'₁d'₂ > n'₂d'₁

6.2.2  Implementação em C++

Definição da classe

class Racional {
  public:
    int n; // numerador
    int d; // denominador
};

Mas uma classe por si só pouco interesse tem.  É necessário definir também as operações que a classe suporta.  Por exemplo, se se pretendesse somar dois racionais, poder-se-ia escrever

Racional soma(Racional a, Racional b)
{
    Racional r;
    r.n = b.d * a.n + a.d * b.n;
    r.d = a.d * b.d;
    return r;
}

Uma possível utilização seria:

#include <iostream>
using namespace std;

class Racional {
  public:
    int n; // numerador
    int d; // denominador
};

Racional soma(Racional a, Racional b)
{
    Racional r;
    r.n = b.d * a.n + a.d * b.n;
    r.d = a.d * b.d;
    return r;
}

int main()
{
    Racional x, y;
    x.n = 1;
    x.d = 0;
    y.n = 7;
    y.d = 15;

    Racional z = soma(x, y);
    cout << z.n << '/' << z.d << endl;
}

Encapsulamento: membros públicos e privados

Podem-se resumir estas ideias num princípio básico da programação:

Princípio do encapsulamento:  O fabricante deve esconder do utilizador final tudo o que puder ser escondido.  I.e., os pormenores de implementação devem ser escondidos, devendo-se fornecer interfaces limpas e simples para a manipulação das entidades fabricadas (aparelhos de cozinha, relógios, funções C++, classes C++, etc.).

Isso consegue-se, no caso das classes, usando o especificador de acesso private: para esconder os membros da classe:

class Racional {
  private:
    int n; // numerador
    int d; // denominador
};

Tornados os membros n e d da classe privados, torna-se impossível na função main() atribuir valores directamente aos seus membros.  Com isso evitam-se possíveis erros cometidos pelos utilizador.  Mas essa solução cria alguns problemas.  Como aceder aos membros na função soma()?  E como inicializar as variáveis e escrever o resultado no ecrã?

Construção da interface: definição de funções membro

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    void escreve();
};

Em primeiro lugar, lembre-se que o acesso aos membros duma classe se faz usando a notação

variável . nome_do_membro

z.escreve();

Assim sendo, uma possível definição da função membro escreve() seria:

void Racional::escreve()
{
    cout << n << '/' << d;
}

x.escreve();
y.escreve();
z.escreve();

Mas há um pormenor na definição da função membro escreve() que é novo: o nome da função é precedido de Racional::.  Esta notação serve para indicar que escreve() é uma função membro da classe Racional, e não uma função vulgar.

Equipada a classe dessa função membro, o programa pode-se escrever:

#include <iostream>
using namespace std;

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    void escreve();
};

// PC:
// CO: aparece no ecrã a representação fraccionária do racional *this, sendo *this a instância da classe implícita na execução da função.
void Racional::escreve()
{
    cout << n << '/' << d;
}

Racional soma(Racional a, Racional b)
{
    Racional r;
    // Erro! Não pode aceder aos membros de a, b e r!
    r.n = b.d * a.n + a.d * b.n;
    r.d = a.d * b.d;
    return r;
}

int main()
{
    Racional x, y;
    // Erro! Não pode aceder aos membros de x e y!
    x.n = 1;
    x.d = 0;
    y.n = 7;
    y.d = 15;

    Racional z = soma(x, y);
    z.escreve();
    cout << endl;
}

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    void escreve();
    Racional soma(Racional b);
};

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução da função.
Racional Racional::soma(Racional b)
{
    Racional r;
    r.n = b.d * n + d * b.n;
    r.d = d * b.d;
    return r;
}

int main()
{
    Racional x, y;
    // Erro! Não pode aceder aos membros de x e y!
    x.n = 1;
    x.d = 0;
    y.n = 7;
    y.d = 15;

    Racional z = x.soma(y);
    z.escreve();
    cout << endl;
}

Inicializando membros privados: construtores

Idealmente seria desejável inicializar essas variáveis usando as formas usuais do C++.  Por exemplo, se se pode escrever

int i = 1;
int j(10);

Racional a = 1;
Racional b(7, 15);

1. São usadas para inicializar as variáveis membro da classe quando uma instância da classe é criada.
2. O seu nome é sempre, por definição, igual ao nome da classe a que pertencem.
3. Não podem devolver qualquer valor em nenhuma circunstância, pelo que no seu cabeçalho não se coloca nunca o tipo de devolução.

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    // Normalmente os construtores são as primeiras funções membro a
    // declarar e a definir:
    Racional(int i);
    void escreve();
    Racional soma(Racional b);
};

Racional::Racional(int i)
{
    n = i;
    d = 1;
}

Racional c;

#include <cstdlib> // para poder usar a função exit().

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    // Normalmente os construtores são as primeiras funções membro a
    // declarar e a definir:
    Racional(int num, int den);
    Racional(int i);
    Racional();
    void escreve();
    Racional soma(Racional b);
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    // Se den = 0, então o programa deve assinalar uma falha
    // grave!  Para já terminar-se-á o programa.  Mais tarde
    // se aprenderão formas mais elegantes de lidar com estes
    // casos:
    if(den == 0) {
        // É má ideia escrever no ecrã aqui, mas por enquanto
        // não conhecemos melhores alternativas:
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
}

// Construtor com um parâmetro (número inteiro):
Racional::Racional(int i)
{
    n = i;
    d = 1;
}

// Construtor sem parâmetros:
Racional::Racional()
{
    n = 0;
    d = 1;
}

Simplificando os construtores: parâmetros com valores por omissão

#include <cstdlib> // para poder usar a função exit().

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    // Normalmente os construtores são as primeiras funções membro a
    // declarar e a definir:
    Racional(int num = 0, int den = 1);
    void escreve();
    Racional soma(Racional b);
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    // Se den = 0, então o programa deve assinalar uma falha
    // grave!  Para já terminar-se-á o programa.  Mais tarde
    // se aprenderão formas mais elegantes de lidar com estes
    // casos:
    if(den == 0) {
        // É má ideia escrever no ecrã aqui, mas por enquanto
        // não conhecemos melhores alternativas:
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
}

O programa completo

#include <iostream>
#include <cstdlib>
using namespace std;

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    // Normalmente os construtores são as primeiras funções membro a
    // declarar e a definir:
    Racional(int num = 0, int den = 1);
    void escreve();
    Racional soma(Racional b);
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    // Se den = 0, então o programa deve assinalar uma falha
    // grave!  Para já terminar-se-á o programa.  Mais tarde
    // se aprenderão formas mais elegantes de lidar com estes
    // casos:
    if(den == 0) {
        // É má ideia escrever no ecrã aqui, mas por enquanto
        // não conhecemos melhores alternativas:
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
}

// PC:
// CO: aparece no ecrã a representação fraccionária do racional *this, sendo *this a instância da classe implícita na execução da função.
void Racional::escreve()
{
    cout << n << '/' << d;
}

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução da função.
Racional Racional::soma(Racional b)
{
    Racional r;
    r.n = b.d * n + d * b.n;
    r.d = d * b.d;
    return r;
}

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x.soma(y);
    z.escreve();
    cout << endl;
}

cout << (*this).n << '/' << (*this).d;

Notas finais

#include <iostream>
#include "racional"

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x + y;
    cout << z << endl;
}

#include <iostream>
#include "racional"

int main()
{
    cout << Racional(1) + Racional(7, 15) << endl;
}

6.2.3  Exercícios

2.  Sendo numerador e denominador representados por variáveis membro do tipo int, é possível que a sua gama de valores admissíveis seja excedido durante o cálculo simplório da soma apresentado (e.g., se os inteiros tivessem 10 bits e fossem representados em complemento para dois, a soma 1/500 + 1/500 daria 1000/250000, em que 250000 excede em muito a gama -512 a 511 correspondente a 10 bits, isto apesar de a soma, em termos mínimos, ser 1/250!).  Reescreva a função soma() evitando tanto quanto possível que a gama dos inteiros seja excedida.

3.  Complete a classe Racional apresentada acima:

a)  Implemente, na forma de funções membro, as operações elementares adicionais usando números racionais (i.e., subtracção, multiplicação e divisão).  Implemente também uma função membro para calcular o simétrico.
b)  Implemente, na forma de funções membro, as operações de comparação e relacionais (i.e., igualdade, diferença, maior, maior ou igual, menor, menor ou igual).
c)  Implemente uma função membro void lê() para ler um número racional do teclado.
d)  Escreva um programa que teste a classe desenvolvida.

6.2.4  Corrigindo a classe Racional

Mas a verdade é que, sendo os int limitados em C++, a utilização duma representação não canónica das fracções põe alguns problemas graves de implementação.  Suponha-se o seguinte código:

int main()
{
    Racional x(1/50000), y(1/50000);
    Racional z = x.soma(y);
    z.escreve();
    cout << endl;
}

1/25000

É pois desejável não só usar uma representação canónica para os racionais, o que de resto simplifica a escrita de operações de comparação, por exemplo, como tentar garantir que os resultados de cálculos intermédios são tão pequenos quanto possível.

Uma nova versão da função mdc()

// PC: m >= 0 e n > 0 e m = m e n = n
// CO: n = mdc(m, n)
int mdc(int m, int n)
{
    while(m != 0) {
        int auxiliar = n % m;
        n = m;
        m = auxiliar;
    }
    return n;
}

// PC: m >= 0 e n >= 0 e (m <> 0 ou n <> 0) em = m e n = n
// CO: n = mdc(m, n)
int mdc(int m, int n)
{
    while(m != 0) {
        int auxiliar = n % m;
        n = m;
        m = auxiliar;
    }
    return n;
}

// Cálculo do mdc de dois números inteiros estendido de modo a funcionar
// para argumentos negativos ou nulos.
// PC: n = n e m = m
// CO: (n = 0 e m = 0 en = 1) ou ((m <> 0 ou n <> 0) en = mdc(|m|, |n|))
int mdc(int m, int n)
{
    if(m == 0 && n == 0)
        return 1;
    if(m < 0)
        m = -m;
    // Aqui forçosamente m = |m| e m >= 0
    if(n < 0)
        n = -n;
    // Aqui m = |m|, m >= 0, e n = |n|, n >= 0, sendo pelo menos um de m e n
    // diferente de zero.
    // CI: mdc(m, n) = mdc(|m|, |n|)
    while(m != 0) {
        int aux = n % m;
        n = m;
        m = aux;
    }
    return n;
}

Uma nova versão da função membro soma()

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução
//    da função.
Racional Racional::soma(Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    int termo = (n / l) * (b.d / k) + (b.n / l) * (d / k);
    int m = mdc(termo, k);
    Racional r;
    r.n = (termo / m) * l;
    r.d = (k / m) * (d / k) * (b.d / k);
    return r;
}

// PC:
// CO: devolve valor lógico de *this < b, sendo *this a instância da classe implícita
//        na execução da função.
Racional Racional::menor(Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    return (n / l) * (b.d / k) < (b.n / l) * (d / k);
}

// PC:
// CO: devolve valor lógico de *this = b, sendo *this a instância da classe implícita
//        na execução da função.
Racional Racional::igual(Racional b)
{
    return n == b.n && d == b.d;
}

Revisão da função construtora

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    // Se den = 0, então o programa deve assinalar uma falha
    // grave!  Para já terminar-se-á o programa.  Mais tarde
    // se aprenderão formas mais elegantes de lidar com estes
    // casos:
    if(den == 0) {
        // É má ideia escrever no ecrã aqui, mas por enquanto
        // não conhecemos melhores alternativas:
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
    // Redução da fracção:
    int k = mdc(n, d);
    n /= k;
    d /= k;
}

Versão completa

#include <iostream>
#include <cstdlib>
using namespace std;

// PC: n = n e m = m
// CO: (n = 0 e m = 0 en = 1) ou ((m <> 0 ou n <> 0) en = mdc(|m|, |n|))
int mdc(int m, int n)
{
    if(m == 0 && n == 0)
        return 1;
    if(m < 0)
        m = -m;
    if(n < 0)
        n = -n;
    while(m != 0) {
        int aux = n % m;
        n = m;
        m = aux;
    }
    return n;
}

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    Racional(int num = 0, int den = 1);
    void escreve();
    Racional soma(Racional b);
    bool igual(Racional b);
    bool menor(Racional b);
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    if(den == 0) {
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
    int k = mdc(n, d);
    n /= k;
    d /= k;
}

// PC:
// CO: aparece no ecrã a representação fraccionária do racional *this, sendo *this
//    a instância da classe implícita na execução da função.
void Racional::escreve()
{
    cout << n << '/' << d;
}

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução
//    da função.
Racional Racional::soma(Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    int termo = (n / l) * (b.d / k) + (b.n / l) * (d / k);
    int m = mdc(termo, k);
    Racional r;
    r.n = (termo / m) * l;
    r.d = (k / m) * (d / k) * (b.d / k);
    return r;
}

// PC:
// CO: devolve valor lógico de *this = b, sendo *this a instância da classe implícita
//        na execução da função.
bool Racional::igual(Racional b)
{
    return n == b.n && d == b.d;
}

// PC:
// CO: devolve valor lógico de *this < b, sendo *this a instância da classe implícita
//        na execução da função.
bool Racional::menor(Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    return (n / l) * (b.d / k) > (b.n / l) * (d / k);
}

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x.soma(y);
    z.escreve();
    cout << endl;
    if(x.menor(y))
        cout << "menor" << endl;
    else
        cout << "maior ou igual" << endl;
    if(x.igual(y))
        cout << "igual" << endl;
    else
        cout << "diferente" << endl;
}

22/15
maior
diferente

6.2.5  Usando sobrecarga de operadores

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x + y;
    z.escreve();
    cout << endl;
    if(x < y)
        cout << "menor" << endl;
    else
        cout << "maior ou igual" << endl;
    if(x == y)
        cout << "igual" << endl;
    else
        cout << "diferente" << endl;
}

A solução para este problema passa pela sobrecarga dos operadores do C++ de modo a terem novos significados quando aplicados ao novo tipo Racional, da mesma forma que se tinha visto antes relativamente aos tipos enumerados (ver Secção 5.1).  Mas, ao contrário do que se fez então, agora as funções de sobrecarga têm de continuar membros da classe Racional de modo a poderem aceder aos seus membros privados (alternativamente poder-se-iam usar funções membro amigas da classe, ver Secção 6.4.6).  Ou seja, a solução é simplesmente:

#include <iostream>
#include <cstdlib>
using namespace std;

// PC: n = n e m = m
// CO: (n = 0 e m = 0 en = 1) ou ((m <> 0 ou n <> 0) en = mdc(|m|, |n|))
int mdc(int m, int n)
{
    if(m == 0 && n == 0)
        return 1;
    if(m < 0)
        m = -m;
    if(n < 0)
        n = -n;
    while(m != 0) {
        int aux = n % m;
        n = m;
        m = aux;
    }
    return n;
}

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    Racional(int num = 0, int den = 1);
    void escreve();
    Racional operator + (Racional b);
    bool operator == (Racional b);
    bool operator < (Racional b);
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    if(den == 0) {
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
    int k = mdc(n, d);
    n /= k;
    d /= k;
}

// PC:
// CO: aparece no ecrã a representação fraccionária do racional *this, sendo *this
//    a instância da classe implícita na execução da função.
void Racional::escreve()
{
    cout << n << '/' << d;
}

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução
//    da função.
Racional Racional::operator + (Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    int termo = (n / l) * (b.d / k) + (b.n / l) * (d / k);
    int m = mdc(termo, k);
    Racional r;
    r.n = (termo / m) * l;
    r.d = (k / m) * (d / k) * (b.d / k);
    return r;
}

// PC:
// CO: devolve valor lógico de *this = b, sendo *this a instância da classe implícita
//        na execução da função.
bool Racional::operator == (Racional b)
{
    return n == b.n && d == b.d;
}

// PC:
// CO: devolve valor lógico de *this < b, sendo *this a instância da classe implícita
//        na execução da função.
bool Racional::operator < (Racional b)
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    return (n / l) * (b.d / k) < (b.n / l) * (d / k);
}

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x + y;
    z.escreve();
    cout << endl;
    if(x < y)
        cout << "menor" << endl;
    else
        cout << "maior ou igual" << endl;
    if(x == y)
        cout << "igual" << endl;
    else
        cout << "diferente" << endl;
}

Em geral, se @ for um operador binário (e.g., +, -, *, etc.), então a sobrecarga do operador @ para uma classe C pode ser feita definindo uma função membro tipo C::operator @ (tipo_do_2º_operando) ou através de uma função normal tipo operator @ (tipo_do_1º_operando, tipo_do_2º_operando).  A expressão a @ b pode portanto ser interpretada como

a.operator @ (b)

operator @ (a, b)

a.operator @ ()

operator @ (a)

1. Quando a sobrecarga se faz por intermédio duma função membro, o primeiro operando (e único no caso duma operação unária) numa expressão que envolva essa operador não sofre nunca conversões de tipo.  Em todos os outros casos as conversões são possíveis.
2. Nunca se deve alterar a semântica dos operadores.  Se se tivesse sobrecarregado o operador + para a classe Racional como significando a multiplicação, imaginam-se os problemas que isso traria!
3. Nem todos os operadores podem ser sobrecarregados por intermédio de funções normais.  Os operadores = (atribuição), [] (indexação), () (invocação) e -> (selecção), só podem ser sobrecarregados por meio de funções membro.

Para todas as classes que não os redifinam, os operadores = (atribuição), & (unário, endereço de) e , (sequenciamento) são definidos implicitamente (por isso é possível atribuir instâncias de classes, como os Racional, sem para isso ter de sobrecarragar o operador =).

6.2.6  Construtores: conversões implícitas e valores literais

Valores literais

Racional r;
r = 1/3;

Mas existe uma alternativa elegante, proporcionada pelos construtores das classes, e que funciona quase como se de valores literais se tratasse: os construtores podem ser chamados explicitamente para criar um novo valor dessa classe.  Assim, o código anterior deveria ser corrigido para:

Racional r;
r = Racional(1, 3);

Conversões implícitas

Racional x(1, 3);
Racional z = x + 1;

Racional x(1, 3);
Racional z = x + Racional(1);

Racional x(1, 3);
Racional z = x + Racional(1, 1);

Em casos em que esta conversão implícita de tipos é indesejável, pode-se preceder o respectivo construtor da palavra chave explicit.  Assim, se a classe Racional estivesse definida como

class Racional {
    ...
  public:
    explicit Racional(int num = 0, int den = 1);
    ...
};

6.2.7  Exercícios

2.  Use sobrecarga de operadores C++ para implementar os operadores de atribuição e incrementação e decrementação típicos (i.e., +=, -=, *=, /=, ++, --) para a classe Racional.

3.  O cálculo da raiz quadrada de um valor v pode ser feito, duma forma algo ineficiente, procurando a solução da equação f(x) = v, onde f(x) := x² (em que se usou a notação := com o significado "é definida por"), usando o método de Newton.  Este método advoga que se deve construir uma sequência r₀, r₁, ... de raízes definida, duma forma recorrente, por r_n+1 = r_n - (r_n² - v) / (2r_n).  Esta sequência converge para a raiz quadrada (positiva) de v quando n tende para infinito, desde que o valor inicial r₀ seja positivo.  Escreva uma função Racional raizQuadrada(Racional v) que calcule um valor racional que aproxime a raiz quadrada do racional v.  Considere a aproximação razoável quando a diferença entre termos sucessivos da sequência for inferior a 1/100 (ou seja, quando |r_n+1 - r_n| = |(r_n² - v) / (2r_n)| < 1/100).

Se procurar a raiz quadrada de 2 usando o método sugerido, chegará à surpreendente fracção 577/408, que é uma excelente aproximação (577/408 = 1,41421568..., cujo quadrado é 2,000006007...).

4. [difícil]  Os inteiros são limitados, pelo que, em máquinas em que os int são representados em complemento para 2 e têm 32 bits, o valor racional mais pequeno (em módulo) representável pela classe Racional tal como desenvolvida é 2^-32 (aproximadamente 10^-10) e o maior (em módulo) 2³² (aproximadamente 10¹⁰).  Se se pretendesse tornar a classe dos racionais verdadeiramente útil, seria necessário estender a gama dos int consideravelmente.  Não sendo isso possível sem mudar de linguagem, compilador, sistema operativo e/ou computador, a solução pode passar por construir uma nova classe Inteiro, à custa da qual a classe Racional pode ser construída, e que represente inteiros de precisão (virtualmente) arbitrária.  Construa essa classe, usando sequências de int para representar os inteiros de precisão arbitrária.  Pode ter de usar memória dinâmica, a ensinar posteriormente.

6.3  Desenho de classes

Suponha-se que se pretende escrever um programa que leia 10 valores inteiros do teclado e os escreva pela ordem inversa no ecrã.  Um pouco de reflexão sobre o problema revela que ele pode ser resolvido com matrizes C++.  Mas, antes de aceitar a solução como evidente, convém pensar um pouco no problema.

Ponha-se no lugar do computador e admita que lhe são passadas 10 folhas de papel, com número escritos, e que as deve devolver pela ordem inversa à da entrega.  Como organizaria as folhas de papel?  A resposta usual a esta pergunta é que os papeis deveriam ser organizados numa pilha (com os números voltados para cima) porque, numa pilha de papeis, o último papel a entrar é o primeiro a sair.

Não há equivalente a uma pilha de papeis na linguagem C++ (embora exista na biblioteca padrão...).  Surge então a ideia de construir uma classe para acrescentar esse conceito ao C++.  Mas resta uma dúvida: sendo o problema tão simples e facilmente resolúvel usando matrizes directamente, porquê definir uma classe nova?

Mais uma vez não existem respostas taxativas a esta questão.  A questão deve ser analisada sob diversos pontos de vista e uma decisão tomada com base nos resultados dessa análise.  Por exemplo:

1. O desenvolvimento da nova classe exige substancialmente mais esforço que uma solução ad hoc?
2. A nova classe pode vir a ser útil no futuro, no mesmo ou noutros programas?
3. A modularização inerente à construção de uma classe vai trazer vantagens para o desenvolvimento e correcção do programa?

6.3.1  Conceito de pilha

Operações com pilhas

Note-se que, ao contrário das operações mais usuais com inteiros, como a soma, subtracção, etc., as operações de inserção e remoção de valores duma pilha afectam a própria pilha.  Seria possível definir as operações de tal modo que a inserção de um valor numa pilha resultasse numa nova pilha, idêntica à original mais com um valor adicional.  As vantagens práticas dum tal conceito são poucas, no entanto.

Pilhas limitadas

Outras operações

6.3.2  Concretização em C++

A interface

class PilhaInt {
    ....
  public:
    PilhaInt();      // construtor da classe.
    void põe(int v); // coloca v no topo da pilha.
    void tira();     // retira valor do topo da pilha.
    int topo();      // devolve valor no topo da pilha.
    bool vazia();    // devolve true sse a pilha estiver vazia.
    bool cheia();    // devolve true sse a pilha estiver cheia.
    int tamanho();   // devolve número de valores na pilha.
};

A implementação

Como é óbvio, sendo a construção de novos tipos um processo incremental de acrescento de funcionalidade à linguagem C++, é evidente que, para guardar os valores inteiros na pilha, ter-se-á de recorrer a conceitos previamente definidos (alternativamente poder-se-ia construir outro novo tipo, embora correndo o risco de entrar num processo recursivo de definição de novos tipos...).  Neste caso pretende-se de algum modo guardar um conjunto de valores todos do mesmo tipo (int).  A forma mais simples de o fazer, em C++, é usando o conceito de matriz.  Assim, os valores guardados na pilha vão, na realidade, ser guardados numa matriz.  Mas as matrizes em C++ têm de ter um tamanho constante.  O tamanho escolhido para a matriz é importante porque corresponde ao limite de valores que as pilhas suportarão.  Para que se possa facilmente alterar o tamanho limite das pilhas, definir-se-á uma constante para representar esse limite.

Assim,

const int limite = 100;

class PilhaInt {
    int valores[limite];
  public:
    PilhaInt();      // construtor da classe.
    void põe(int v); // coloca v no topo da pilha.
    void tira();     // retira valor do topo da pilha.
    int topo();      // devolve valor no topo da pilha.
    bool vazia();    // devolve true sse a pilha estiver vazia.
    bool cheia();    // devolve true sse a pilha estiver cheia.
    int tamanho();   // devolve número de valores na pilha.
};

const int limite = 100;

class PilhaInt {
    int valores[limite];
    int quantos;
  public:
    PilhaInt();      // construtor da classe.
    void põe(int v); // coloca v no topo da pilha.
    void tira();     // retira valor do topo da pilha.
    int topo();      // devolve valor no topo da pilha.
    bool vazia();    // devolve true sse a pilha estiver vazia.
    bool cheia();    // devolve true sse a pilha estiver cheia.
    int tamanho();   // devolve número de valores na pilha.
};

É agora possível definir cada uma das funções e procedimentos membro da classe.  Como é usual, começa-se pelos construtores (neste caso apenas existe um).  O construtor limite-se a colocar quantos a zero, o que é o mesmo que dizer que as pilhas, quando criadas, estão vazias:

PilhaInt::PilhaInt()
{
    quantos = 0;
}

Em seguida definem-se as funções membro vazia() e cheia(), por exemplo.  Como é óbvio, uma pilha está vazia sse quantos = 0 e está cheira sse quantos = limite.  Assim:

bool PilhaInt::vazia()
{
    return quantos == 0;
}

bool PilhaInt::cheia()
{
    return quantos == limite;
}

int PilhaInt::tamanho()
{
    return quantos;
}

void PilhaInt::põe(int v)
{
    if(cheia()) {
        cerr << "Erro: pilha cheia." << endl;
        exit(1);
    }
    valores[quantos++] = v;
}

void PilhaInt::tira()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    quantos--;
}

int PilhaInt::topo()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    return valores[quantos - 1];
}

void PilhaInt::põe(int v)
{
    if(cheia()) {
        ...
    }
    valores[quantos] = v;
    quantos = quantos + 1;
}

valores[++quantos] = v;

quantos = quantos + 1;
valores[quantos] = v;

Class e struct

Constantes membro

class PilhaInt {
    const int limite = 100;  // erro!
    int valores[limite];
    ....
}

class Aluno {
    const int número;
    int nota;
    ...
  public:
    Aluno(int n);
};

Aluno::Aluno(int n) : número(n) {
    ...
}

6.3.3  O programa completo

#include <iostream>
using namespace std;

const int limite = 100;

class PilhaInt {
    int valores[limite];
    int quantos;
  public:
    PilhaInt();      // construtor da classe.
    void põe(int v); // coloca v no topo da pilha.
    void tira();     // retira valor do topo da pilha.
    int topo();      // devolve valor no topo da pilha.
    bool vazia();    // devolve true sse a pilha estiver vazia.
    bool cheia();    // devolve true sse a pilha estiver cheia.
    int tamanho();   // devolve número de valores na pilha.
};

PilhaInt::PilhaInt()
{
    quantos = 0;
}

bool PilhaInt::vazia()
{
    return quantos == 0;
}

bool PilhaInt::cheia()
{
    return quantos == limite;
}

int PilhaInt::tamanho()
{
    return quantos;
}

void PilhaInt::põe(int v)
{
    if(cheia()) {
        cerr << "Erro: pilha cheia." << endl;
        exit(1);
    }
    valores[quantos++] = v;
}

void PilhaInt::tira()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    quantos--;
}

int PilhaInt::topo()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    return valores[quantos - 1];
}

int main()
{
    PilhaInt pilha;

    // Coloca 10 valores na pilha:
    for(int i = 0; i != 10; i++) {
        int v;
        cin >> v;
        pilha.põe(v);
    }

    // Escreve-os pela ordem inversa:
    while(!pilha.vazia()) {
        cout << pilha.topo() << endl;
        pilha.tira();
    }
}

6.3.4  Condição invariante de instância

A vantagem da definição duma CII para a classe tem a ver com o facto de todas as funções e procedimentos membro públicos bem como as funções e procedimentos amigas (parte da interface da classe com o utilizador) poderem admitir que as instâncias da classe com que trabalham verificam inicialmente a CII, o que normalmente as simplifica bastante.  I.e., a CII para cada instância em causa é parte da PC de cada uma dessas funções e procedimentos.  Claro que, para serem "bem comportadas", essas funções e procedimentos devem também garantir que a CII se verifica para todas as instâncias da classe criadas ou alteradas pela função.  Ou seja, a CO dessas funções e procedimentos inclui também a CII para cada instância da classe criada ou alterada.

Assim, como todas funções e procedimentos que podem criar e alterar instâncias da classe em causa garantem que todas instâncias alteradas ou criadas verificam a CII, esta condição verifica-se sempre, excepto, possivelmente, durante a execução dessas mesmas funções e procedimentos.

Tal como sucedia nos ciclos, em que durante a execução do passo a CI muitas vezes não se verificava, embora se verificasse garantidamente antes e após o passo, também a CII pode não se verificar durante a execução das funções e procedimentos membro (e públicos) ou amigos da classe em causa, embora se verifique garantidamente no seu início e no seu final.  Acontece que, durante esses períodos em que a CII não se verifica, pode ser conveniente invocar alguma função ou procedimento membro auxiliar, que portanto terá de lidar com instâncias que não verifiquem inicialmente a CII e que poderão não garantir que a verificam as instâncias por si criada ou alteradas.  Essas funções e procedimentos "mal comportados" devem ser privados, de modo a evitar utilizações erróneas por parte do utilizador final da classe que coloquem alguma instância num estado inválido (em que a CII não se verifica).

Note-se que a definição de uma CII e de funções e procedimentos membro e funções e procedimentos amigos para uma classe não passam de um esforço inútil se as variáveis membro envolvidas na CII forem públicas.  É que, se o forem, o utilizador da classe pode alterá-las por engano ou maliciosamente, invalidando a CII, com consequências potencialmente dramáticas no comportamento da classe e no programa no seu todo.  Essas consequências são normalmente graves porque as funções e procedimentos que lidam com as variáveis membro da classe assumem que estas verificam a CII, não fazendo quaisquer garantias acerca do seu funcionamento quando a CII não se verifica.

De todas as funções e procedimentos membro de uma classe com CII, porventura as mais importantes sejam as funções construtoras.  É que estas são as que garantem que as instâncias são criadas verificando imediatamente a CII.  A sua importância pode ser vista na classe Racional, em que o construtor garante, se tal for possível, que a CII da classe se verifica, abortando o programa caso tal seja impossível.

Finalmente, é de notar que algumas classes não têm CII.  Essas classes são normalmente meros repositórios de informação.  É o caso, por exemplo, duma classe que guarde nome e morada de utentes de um serviço qualquer.  Essas classes têm normalmente todas as suas variáveis membro públicas, e portanto usam normalmente a palavra chave struct em vez de class no C++.

O caso da classe Racional

O objectivo da função Racional::operator + () é calcular a soma de duas fracções n₁/d₁ e n₂/d₂.  A função para o cálculo da soma assume que ambas as fracções verificam a CII, i.e., que mdc(n₁, d₁) = 1 e d₁ > 0 e mdc(n₂, d₂) = 1 e d₂ > 0 (quando dois inteiros x e y são tais que mdc(x, y) = 1, diz-se que x e y são mutuamente primos).  O objectivo é calcular uma fracção n/d = n₁/d₁ + n₂/d₂ que verifique também a CII, i.e., mdc(n, d) = 1 e d > 0.

Sejam l = mdc(n₁, n₂) (se n₁ e n₂ forem ambos zero, faz-se l = 1) e k = mdc(d₁, d₂) (note-se que l > 0 e k >0, por definição do mdc).  Então, é evidente que

n₁/d₁ + n₂/d₂ = l/k (n'₁/d'₁ + n'₂/d'₂)

n'₁ = n₁ / l
n'₂ = n₂ / l
d'₁ = d₁ / k
d'₂ = d₂ / k

Ou seja,

n₁/d₁ + n₂/d₂ = (l (n'₁d'₂ + n'₂d'₁)) / (kd'₁d'₂)

Será que pode haver termos (não unitários) comuns a l e a k?  Suponha-se que existe um x > 1 divisor de l e de k.  Nesse caso, x é também divisor de n₁, d₁, n₂, e d₂.  Mas isso não pode acontecer pois, por hipótese, mdc(n₁, d₁) = 1 e mdc(n₂, d₂) = 1.  Logo, l e k não têm termos (não unitários) comuns.

Será que pode haver termos comuns a l e a d'₁d'₂?  Suponha-se que existe um x > 1 divisor de l e de d'₁d'₂.  Nesse caso, existe forçosamente um y > 1 divisor de l e de d'₁ ou de d'₂.  Se y for divisor de l e de d'₁, então y é também divisor de n₁ e d₁, o que é impossível, pois por hipótese mdc(n₁, d₁) = 1.  O mesmo argumento se aplica se y for divisor de l e de d'₂.  Logo,  l e d'₁d'₂ não têm termos (não unitários) comuns.

Será que podem haver termos comuns a n'₁d'₂ + n'₂d'₁ e a d'₁d'₂?  Suponha-se que existe um x > 1 divisor de n'₁d'₂ + n'₂d'₁ e de d'₁d'₂.  Nesse caso, existe forçosamente um y > 1 divisor de n'₁d'₂ + n'₂d'₁ e de d'₁ ou de d'₂.  Se y for divisor de n'₁d'₂ + n'₂d'₁ e de d'₁, então y tem de dividir também n'₁ ou d'₂.  Mas isso não pode acontecer, pois implicaria que mdc(n₁, d₁) <> 1, o que é impossível por hipótese, ou mdc(d'₁, d'₂) <> 1, o que não pode acontecer por construção de d'₁ e d'₂.  O mesmo argumento se aplica se y for divisor de n'₁d'₂ + n'₂d'₁ e de d'₂.  Logo, n'₁d'₂ + n'₂d'₁ e d'₁d'₂ não têm termos (não unitários) comuns.

Assim, a existirem termos comuns (não unitários) ao denominador e numerador da fracção

(l (n'₁d'₂ + n'₂d'₁)) / (kd'₁d'₂)

m = mdc(n'₁d'₂ + n'₂d'₁, k)

n₁/d₁ + n₂/d₂ = (l (n'₁d'₂ + n'₂d'₁)/m) / ((k/m)d'₁d'₂)

Qual foi a vantagem de factorizar l e k e proceder aos restantes cálculos face à alternativa, mais simples, de calcular a fracção como

n₁/d₁ + n₂/d₂ = ((n₁d₂ + n₂d₁)/h) / (d₁d₂)/h)

A vantagem é meramente computacional.  Apesar de os cálculos propostos exigirem mais operações, os valores intermédios dos cálculos são em geral mais pequenos, o que minimiza a possibilidade de existirem valores intermédios não representáveis nos inteiros da linguagem de programação em causa (C++).

6.4  Mais sobre classes em C++

6.4.1  Funções e procedimentos inline

Para definir uma função ou procedimento membro como inline, podem-se fazer uma de duas coisas:

1. Ao definir a classe definir logo a função ou procedimento membro (em vez de a declarar apenas).
2. Ao definir a função ou procedimento membro declarada na definição da classe, preceder o seu cabeçalho do qualificador inline.

class PilhaInt {
    ...
    int tamanho() {
        return quantos;
    }
    ...
}

class PilhaInt {
    ...
    int tamanho();
    ...
}
...
inline int PilhaInt::tamanho()
{
    return quantos;
}

Note-se que não só as funções ou procedimentos membro duma classe podem ser inline: qualquer função ou procedimento pode ser definido como inline, bastando para isso usar o qualificador inline.  Note-se ainda que a definição de uma função ou procedimento como inline não altera a semântica da sua chamada, tendo apenas consequências em termos da tradução, pelo compilador, para código máquina.

Nova versão do programa das pilhas

#include <iostream>
using namespace std;

const int limite = 100;

class PilhaInt {
    int valores[limite];
    int quantos;
  public:
    PilhaInt();      // construtor da classe.
    void põe(int v); // coloca v no topo da pilha.
    void tira();     // retira valor do topo da pilha.
    int topo();      // devolve valor no topo da pilha.
    bool vazia();    // devolve true sse a pilha estiver vazia.
    bool cheia();    // devolve true sse a pilha estiver cheia.
    int tamanho();   // devolve número de valores na pilha.
};

inline PilhaInt::PilhaInt()
{
    quantos = 0;
}

inline bool PilhaInt::vazia()
{
    return quantos == 0;
}

inline bool PilhaInt::cheia()
{
    return quantos == limite;
}

inline int PilhaInt::tamanho()
{
    return quantos;
}

inline void PilhaInt::põe(int v)
{
    if(cheia()) {
        cerr << "Erro: pilha cheia." << endl;
        exit(1);
    }
    valores[quantos++] = v;
}

inline void PilhaInt::tira()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    quantos--;
}

inline int PilhaInt::topo()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    return valores[quantos - 1];
}

int main()
{
    PilhaInt pilha;

    // Coloca 10 valores na pilha:
    for(int i = 0; i != 10; i++) {
        int v;
        cin >> v;
        pilha.põe(v);
    }

    // Escreve-os pela ordem inversa:
    while(!pilha.vazia()) {
        cout << pilha.topo() << endl;
        pilha.tira();
    }
}

6.4.2  Funções e procedimentos membro constantes

const Racional um = 1;
const Racional zero = 0;

Racional z = um + zero;

Para obviar a este comportamento, que impede a soma de uma constante com qualquer outro Racional, é necessário indicar ao compilador que a função membro operator +() é bem comportada, i.e., não altera a instância passada por referência implicitamente.  Para isso coloca-se o qualificador const após quer a declaração quer a definição da função membro:

class Racional {
    ...
 public:
    Racional operator + (Racional b) const;
    ...
};
...
Racional Racional::operator + (Racional b) const
{
    ...
}

É uma boa regra declarar como const todas as funções e procedimentos membro que não efectem a instância implícita.  Assim, apresentam-se abaixo versões melhoradas dos programas desenvolvidos:

Nova versão do programa com racionais

#include <iostream>
#include <cstdlib>
using namespace std;

// PC: n = n e m = m
// CO: (n = 0 e m = 0 en = 1) ou ((m <> 0 ou n <> 0) en = mdc(|m|, |n|))
int mdc(int m, int n)
{
    if(m == 0 && n == 0)
        return 1;
    if(m < 0)
        m = -m;
    if(n < 0)
        n = -n;
    while(m != 0) {
        int aux = n % m;
        n = m;
        m = aux;
    }
    return n;
}

class Racional {
  private:
    int n; // numerador
    int d; // denominador
  public:
    Racional(int num = 0, int den = 1);
    void escreve() const;
    Racional operator + (Racional b) const;
    bool operator == (Racional b) const;
    bool operator < (Racional b) const;
};

// Construtor com dois parâmetros (numerador e denominador):
Racional::Racional(int num, int den)
{
    if(den == 0) {
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        n = -num;
        d = -den;
    } else {
        n = num;
        d = den;
    }
    int k = mdc(n, d);
    n /= k;
    d /= k;
}

// PC:
// CO: aparece no ecrã a representação fraccionária do racional *this, sendo *this
//    a instância da classe implícita na execução da função.
inline void Racional::escreve() const
{
    cout << n << '/' << d;
}

// PC:
// CO: r = *this + b, sendo *this a instância da classe implícita na execução
//    da função.
Racional Racional::operator + (Racional b) const
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    int termo = (n / l) * (b.d / k) + (b.n / l) * (d / k);
    int m = mdc(termo, k);
    Racional r;
    r.n = (termo / m) * l;
    r.d = (k / m) * (d / k) * (b.d / k);
    return r;
}

// PC:
// CO: devolve valor lógico de *this = b, sendo *this a instância da classe implícita
//        na execução da função.
inline bool Racional::operator == (Racional b) const
{
    return n == b.n && d == b.d;
}

// PC:
// CO: devolve valor lógico de *this > b, sendo *this a instância da classe implícita
//        na execução da função.
bool Racional::operator < (Racional b) const
{
    int l = mdc(n, b.n);
    int k = mdc(d, b.d);
    return (n / l) * (b.d / k) > (b.n / l) * (d / k);
}

int main()
{
    Racional x = 1, y(7, 15);
    Racional z = x + y;
    z.escreve();
    cout << endl;
    if(x < y)
        cout << "menor" << endl;
    else
        cout << "maior ou igual" << endl;
    if(x == y)
        cout << "igual" << endl;
    else
        cout << "diferente" << endl;
}

Nova versão do programa com pilhas

#include <iostream>
using namespace std;

const int limite = 100;

class PilhaInt {
    int valores[limite];
    int quantos;
  public:
    PilhaInt();          // construtor da classe.
    void põe(int v);     // coloca v no topo da pilha.
    void tira();         // retira valor do topo da pilha.
    int topo() const;    // devolve valor no topo da pilha.
    bool vazia() const;  // devolve true sse a pilha estiver vazia.
    bool cheia() const;  // devolve true sse a pilha estiver cheia.
    int tamanho() const; // devolve número de valores na pilha.
};

inline PilhaInt::PilhaInt()
{
    quantos = 0;
}

inline int PilhaInt::tamanho() const
{
    return quantos;
}

inline bool PilhaInt::vazia() const
{
    return tamanho() == 0;
}

inline bool PilhaInt::cheia() const
{
    return tamanho() == limite;
}

inline void PilhaInt::põe(int v)
{
    if(cheia()) {
        cerr << "Erro: pilha cheia." << endl;
        exit(1);
    }
    valores[quantos++] = v;
}

inline void PilhaInt::tira()
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    quantos--;
}

inline int PilhaInt::topo() const
{
    if(vazia()) {
        cerr << "Erro: pilha vazia." << endl;
        exit(1);
    }
    return valores[tamanho() - 1];
}

int main()
{
    PilhaInt pilha;

    // Coloca 10 valores na pilha:
    for(int i = 0; i != 10; i++) {
        int v;
        cin >> v;
        pilha.põe(v);
    }

    // Escreve-os pela ordem inversa:
    while(!pilha.vazia()) {
        cout << pilha.topo() << endl;
        pilha.tira();
    }
}

6.4.3  Referências

int incrementa(int& x)
{
    x++;
    return x;
}

#include <iostream>
using namespace std;

int incrementa(int& x)
{
    x++;
    return x;
}

int main()
{
    int y = 1;
    incrementa(y);
    cout << y << endl;
}

Mas o conceito de referência pode ser usado de formas diferentes.  Por exemplo,

int i = 1;
int& j = i; // a partir daqui j é sinónimo de i
j = 3;
cout << i << endl;

As variáveis que são referências, caso do j no exemplo anterior e do parâmetro x do procedimento iincrementa(), têm de ser inicializadas com a variável de que são sinónimos.  Essa inicialização é feita explicitamente no caso de j e implicitamente no caso da variável x, neste caso através da passagem de y como argumento na chamada de incrementa().

Devolução de referências

#include <iostream>
using namespace std;

int incrementa(int& x)
{
    x++;
    return x;
}

int main()
{
    int y = 1;
    incrementa(incrementa(y)); // erro!
    cout << y << endl;
}

#include <iostream>
using namespace std;

int& incrementa(int& x)
{
    x++;
    return x;
}

int main()
{
    int y = 1;
    incrementa(incrementa(y));
    cout << y << endl;
}

Na realidade, ao devolver numa função ou procedimento uma referência, está-se a dar a possibilidade ao utilizador da função ou procedimento de colocar a sua invocação do lado esquerdo da atribuição.  Por exemplo, definido o procedimento incrementa() como acima, é possível escrever código como:

int a = 11;
incrementa(a) = 0;  // possível (mas absurdo), incrementa e depois atribui zero a a.
incrementa(a) /= 2; // possível, incrementa e depois divide a por dois.

#include <iostream>
#include <vector>
#include <cstdlib>

using namespace std;

class VectorInt {
    vector<int> v;
  public:
    VectorInt(int t);
    // ...
    int& operator [] (int i);
    // ...
};

VectorInt::VectorInt(int t) : v(t) {
}

//...

// vector<int>::size_type é um tipo inteiro sem sinal usado para
// guardar tamanhos e para os índices dos vectores:
int& VectorInt::operator [] (vector<int>::size_type i) {
    if(i < 0 || i >= v.size()) {
        // Há melhores formas de lidar com o erro!
        cerr << "Erro: índice inválido." << endl;
        exit(1);
    }
    return v[i];
}

int main()
{
    VectorInt v(10);

    v[0] = 1;
    v[10] = 3; // índice errado! aborta com mensagem de erro.
}

Operador ++ prefixo para a classe Racional

n/d + 1 = (n + d)/d

Assim, o operador ++ prefixo pode ser definido simplesmente como

class Racional {
    ...
    public:
    ...
    Racional& operator ++ ();
};

...

inline Racional& operator ++() {
    n += d;
    return *this;
}

Racional r = 1;
++ ++r;

Operador ++ sufixo para a classe Racional

Por outro lado, como é que se pode indicar ao compilador, na definição do operador, que nos estamos a referir ao operador ++ sufixo e não ao operador ++ prefixo?  Isso faz-se usando um método pouco elegante: acrescentando um parâmetro do tipo int no seu cabeçalho.

Finalmente, é importante perceber que, uma vez definido o operador ++ prefixo, é possível recorrer a ele para construir o operador ++ sufixo: i.e., o novo operador a definir não precisa de ser uma função (ou procedimento) membro, podendo ser uma função (ou procedimento) normal.  É boa política definir como funções (ou procedimentos) membro apenas as funções (ou procedimentos) que de facto necessitem de o ser, i.e., que precisem de aceder (em geral alterar) aos membros privados da classe.

Assim, usando as ideias acima, o operador ++ sufixo poderia ser definido para a classe Racional como se segue:

class Racional {
    ...
    public:
    ...
    Racional& operator ++ ();
};

...

// Incrementação prefixa:
inline Racional& operator ++() {
    n += d;
    return *this;
}
// Incrementação sufixa:
inline Racional operador ++(Racional& r, int) {
    Racional temporário = r;
    ++r;
    return temporário;
}

Racional r;
r++ ++; // erro!

Referências constantes

#include <vector>

int soma(std::vector<int> v)
{
    int s = 0;
    for(int i = 0; i != v.size(); i++)
        s += v[i];
    return s;
}

#include <vector>

int soma(std::vector<int>& v) // má ideia!
{
    int s = 0;
    for(int i = 0; i != v.size(); i++)
        s += v[i];
    return s;
}

#include <vector>

int soma(const std::vector<int>& v) // boa ideia!
{
    int s = 0;
    for(int i = 0; i != v.size(); i++)
        s += v[i];
    return s;
}

// Mau código.  Bom para exemplos apenas...
int soma1(int& a, int& b) {
    return a + b;
}

int soma2(const int& a, const int& b) {
    return a + b;
}

int main()
{
    int i = 1, j = 2, res;
    res = soma1(i, j); // válido
    res = soma2(i, j); // válido
    res = soma1(10, 20); // erro!
    res = soma2(10, 20); // válido!
}

6.4.4  Destrutores

#include <iostream>
using namespace std;

class C {
    public:
        C() {
            cout << "Construí uma instância de C!" << endl;
        }
        ~C() {
            cout << "Destruí uma instância de C!" << endl;
        }
};

int main()
{
    C c; // criação duma instância de C chamada c.
    for(int i = 0; i != 3; i++) {
        C outra; // criação duma instância de C chamada outra.
        cout << i << endl;
        // Quando o bloco de instruções termina, outra é destruída.
    }
    // Quando o bloco de instruções termina, c é destruída.
}

A execução deste programa resulta em:

Construí uma instância de C!
Construí uma instância de C!
0
Destruí uma instância de C!
Construí uma instância de C!
1
Destruí uma instância de C!
Construí uma instância de C!
2
Destruí uma instância de C!
Destruí uma instância de C!

6.4.5  Membros de classe

Suponha-se que se criar uma classe C que mantivesse uma contagem do número de instâncias existente em cada instante.  Uma possibilidade seria:

class C {
    static int número_de_instâncias;
  public:
    C() {
        número_de_instâncias++;
    }
    ~C() {
        número_de_instâncias--;
    }
    static int númeroDeInstâncias();
};

int C::número_de_instâncias = 0;

int C::númeroDeInstâncias() {
    return número_de_instâncias;
}

Uma possível utilização da classe seria

#include <iostream>
using namespace std;

class C {
    static int número_de_instâncias;
  public:
    C() {
        número_de_instâncias++;
    }
    ~C() {
        número_de_instâncias--;
    }
    static int númeroDeInstâncias();
};

int C::número_de_instâncias = 0;

int C::númeroDeInstâncias() {
    return númeroDeInstâncias;
}

int main()
{
    {
        C a, b;
        for(int i = 0; i != 3; i++) {
            C x;
            cout << "Existem " << C::númeroDeInstâncias()
                 << " instâncias." << endl;
        }
        cout << "Existem " << C::númeroDeInstâncias()
             << " instâncias." << endl;
    }
    cout << "Existem " << C::númeroDeInstâncias()
         << " instâncias." << endl;
}

A execução do programa acima teria como resultado:

Existem 3 instâncias.
Existem 3 instâncias.
Existem 3 instâncias.
Existem 2 instâncias.
Existem 0 instâncias.

6.4.6  Funções amigas

Racional r(1, 3);
cout << r << endl;

1/3

inline ??? operator << (ostream& saída, Racional r) {
    saída << r.n << '/' << r.d;
    return ???;
}

class Racional {
    ...
    friend ??? operator << (ostream& saída, Racional r);
    ...
};

...

inline ??? operator << (ostream& saída, Racional r) {
    saída << r.n << '/' << r.d;
    return ???;
}

inline ostream& operator << (ostream& saída, Racional r) {
    saída << r.n << '/' << r.d;
    return saída;
}

inline ostream& operator << (ostream& saída, Racional r) {
    return saída << r.n << '/' << r.d;
}

Quando usar funções amigas

Seria possível definir o operador << para escrita em canais de instâncias da classe Racional sem recorrer à declaração do operador como friend?  Sim.  Para isso basta reconhecer que faltam à classe Racional duas funções membro que podem ser muito úteis para o utilizador final.  Afinal, não é útil poder saber qual o numerador e qual o denominador da fracção canónica correspondente a um racional?  Para isso basta definir duas funções membro públicas adicionais numerador() e denominador() que devolvam esses valores.  Note-se que esta solução não põe de todo em causa o princípio do encapsulamento, pois as variáveis membro continuam a ser impossíveis de alterar directamente pelo utilizador da classe.  Assim, uma solução preferível à anterior seria:

class Racional {
    int n;
    int d;
  public:
    ...
    int numerador() const;
    int denominador() const;
    ...
};

...

inline int Racional::numerador() const {
    return n;
}

inline int Racional::denominador() const {
    return d;
}

...

inline ostream& operator << (ostream& saída, Racional r) {
    return saída << r.numerador() << '/' << r.denominador();
}

A definição das duas novas funções membro da classe Racional trará outras consequências benéficas, como se verá mais abaixo.

6.4.7  Construtores por omissão e matrizes de classes

Construtores por omissão

class C {
    Racional r1;
    Racional r2;
    int i;
};

C c; // nova instância, construtor por omissão invocado.

C c = C();

class C {
    Racional r1;
    Racional r2;
    int i;
  public:
    C() : r1(), r2() {}
};

class C {
    Racional r1;
    Racional r2;
    int i;
  public:
    C() {
    }
};

class C {
    Racional r1;
    Racional r2;
    int i;
  public:
    C(int n, int d, int ii) : r1(n, d), i(ii) {
        r2 = 3;
    }
};

C c(2, 10, 1);

1. Chamada do construtor de r1 com argumentos n e d (que neste caso inicializa r1 com 1/5).
2. Chamada implícita do construtor por omissão de r2 (que inicializa r2 com 0/1).
3. Inicialização de i com ii (neste caso com 1).
4. Execução do corpo do construtor de C:
1. Conversão de 3 de int para Racional.
2. Atribuição do racional 3/1 a r2.

Note-se que a classe C não tem construtor por omissão.  Desse modo, seria um erro escrever:

C c; // erro!

Matrizes de classe

Racional m1[10] = {Racional()};
Racional m2[10] = {1, 2, Racional(3), Racional(1, 3)};

Note-se que, se a classe em causa não possuir construtores por omissão, é obrigatório inicializar todos os elementos da matriz explicitamente, e também que as conversões podem precisar de ser explicitadas  Por exemplo:

class C {
    int valor;
  public:
    // Construtor explícito inline que inicializa valor com conteúdo de i:
    explicit C(int i) : valor(i) {}
};

C matriz[5];                      // erro! não tem construtor por omissão.
C matriz[5] = {C(1), C(2), C(3)}; // erro! inicializadores insuficientes.
C matriz[5] = {C(1), 2, 3, 4, 5}; // erro! conversão implícita impossível.
C matriz[5] = {C(1), C(2), C(3), C(4), C(5)}; // ok!

6.4.8  Conversões para outros tipos

Racional r(1, 3);
...
if(r < 1) // 1 convertido inplicitamente de int para Racional.

Racional r(1, 3);
...
if(r < Racional(1)) // não é necessário...

Racional r(1, 2);
double x = r;
cout << r << ' ' << x << endl; // imprime '1/2 0.5'.
cout << double(r) << endl;     // imprime '0.5'.

1. Só podem ser sobrecarregados através de funções membro a classe a converter.
2. Não incluem tipo de devolução, pois este é indicado no nome do operador.

class Racional {
    ...
  public:
    ...
    operator double() const;
    ...
};

...

Racional::operator double() const {
    return double(numerador()) / double(denominador());
}

O problema deste tipo de operadores de conversão de tipo, que devem ser usados com moderação, é que levam frequentemente a ambiguidades.  Por exemplo, definido o operador de conversão para double de valores da classe Racional, como deve ser interpretado o seguinte código:

Racional r(1,3);
...
if(r == 1)
    ...

Uma aplicação mais útil

class Palavra {
    int valor;
  public:
    Palavra(int v = 0);
    operator int() const;
    bool bit(int n) const;
};

inline Palavra::Palavra(int v) : valor(v) {
}

inline Palavra::operator int () const {
    return valor;
}

inline bool Palavra::bit(int n) const {
    return (unsigned(valor) & (1 << n)) != 0U;
}

Palavra p = 99996;
p = p + 4;
std::cout << "Valor é: " << p << std::endl;
std::cout << "Em binário: ";
for(int i = 31; i >= 0; i--)
    std::cout << p.bit(i);
std::cout << std::endl;

Valor é: 100000
Em binário: 00000000000000011000011010100000

6.4.9  Novamente os racionais

1. Existem agora (de novo) três diferentes construtores.  A separação do construtor único usado anteriormente e três construtores fez-se por usam questão de eficiência, pois se evitam no construtor por omissão e no construtor a partir de um inteiro as verificações que são necessárias no construtor mais geral para garantir que a CII se verifica.
2. Introduziram-se funções membro públicas que permitem ao utilizador saber o valor do numerador e do denominador da fracção canónica.  Essas funções membro permitiram também transformar em funções normais algumas funções que antes eram membro, com as vantagens daí resultantes.  Por exemplo, sendo o operador == entre racionais definido como função normal (não membro), qualquer das expressões 1 == r e r == 1 é válida quando r é um Racional, coisa que não acontecia se o operador == fosse definido como função membro, pois nesse caso só a segunda expressão seria legal (o operando correspondente à instância implícita na chamada duma função membro nunca é convertido noutro tipo).
3. Embora as conversões implícitas sejam úteis, é muitas vezes mais eficiente fornecer operadores especializados em trabalhar com determinados tipos.  Por exemplo, é muito mais rápida a soma de uma int com um Racional do que a soma de dois Racionais.  Por isso se fornecem versões especializadas das operações quando envolvem ints.
4. Quase todas as funções e procedimentos são inline.  Isso deve-se à sua simplicidade (em geral têm um número pequeno de instruções) e ao facto de as operações aritméticas com Racionais serem possivelmente das executadas maior número de vezes no código do utilizador típico (aqui o fabricante não pode fazer melhor que tentar adivinhar as necessidades do utilizador típico do seu produto...).
5. Note-se que, para encurtar a apresentação do programa, se eliminaram a maior parte dos comentários.  Não tome essa eliminação como exemplo!

#include <iostream>
#include <cstdlib>
using namespace std;

int mdc(int m, int n)
{
    if(m == 0 && n == 0)
        return 1;
    if(m < 0)
        m = -m;
    if(n < 0)
        n = -n;
    while(m != 0) {
        int aux = n % m;
        n = m;
        m = aux;
    }
    return n;
}

class Racional {
private:
    int n;
    int d;
public:
    Racional();
    Racional(int i);
    Racional(int num, int den);
    int numerador() const;
    int denominador() const;
    Racional& operator += (Racional b);
    Racional& operator += (int i);
    Racional& operator ++ ();
    Racional& operator -= (Racional b);
    Racional& operator -= (int i);
    Racional& operator -- ();
    Racional operator - () const;
    Racional& operator *= (Racional b);
    Racional& operator *= (int i);
    Racional& operator /= (Racional b);
    Racional& operator /= (int i);
    friend Racional operator / (int i, Racional a);
};

inline int Racional::numerador() const {
    return n;
}

inline int Racional::denominador() const {
    return d;
}

inline Racional::Racional() {
    n = 0;
    d = 1;
}

inline Racional::Racional(int i) {
    n = i;
    d = 1;
}

inline Racional::Racional(int num, int den) {
    if(den == 0) {
        cerr << "Erro: denominador inválido!" << endl;
        exit(1);
    } else if(den < 0) {
        num = -num;
        den = -den;
    }
    int k = mdc(num, den);
    n = num / k;
    d = den / k;
}

inline Racional& Racional::operator += (Racional b) {
    int l = mdc(numerador(), b.numerador());
    int k = mdc(denominador(), b.denominador());
    int dk = denominador() / k;
    int bdk = b.denominador() / k;
    int termo = (numerador() / l) * bdk + (b.numerador() / l) * dk;
    int m = mdc(termo, k);
    n = (termo / m) * l;
    d = (k / m) * dk * bdk;
    return *this;
}

inline Racional& Racional::operator += (int i) {
    n += denominador() * i;
    return *this;
}

inline Racional& Racional::operator ++ () {
    n += denominador();
    return *this;
}

inline Racional& Racional::operator -= (Racional b) {
    int l = mdc(numerador(), b.numerador());
    int k = mdc(denominador(), b.denominador());
    int dk = denominador() / k;
    int bdk = b.denominador() / k;
    int termo = (numerador() / l) * bdk - (b.numerador() / l) * dk;
    int m = mdc(termo, k);
    n = (termo / m) * l;
    d = (k / m) * dk * bdk;
    return *this;
}

inline Racional& Racional::operator -= (int i) {
    n -= denominador() * i;
    return *this;
}

inline Racional& Racional::operator -- () {
    n -= denominador();
    return *this;
}

inline Racional Racional::operator - () const {
    Racional r;
    r.n = -numerador();
    r.d = denominador();
    return r;
}
 

inline Racional& Racional::operator *= (Racional b) {
    int l = mdc(denominador(), b.numerador());
    int k = mdc(numerador(), b.denominador());
    n = (numerador() / k) * (b.numerador() / l);
    d = (denominador() / l) * (b.denominador() / k);
    return *this;
}

inline Racional& Racional::operator *= (int i) {
    int l = mdc(denominador(), i);
    n *= i / l;
    d /= l;
    return *this;
}

inline Racional& Racional::operator /= (Racional b) {
    if(b.numerador() == 0) {
        cerr << "Erro: divisão por zero!" << endl;
        exit(1);
    }
    int l = mdc(numerador(), b.numerador());
    int k = mdc(denominador(), b.denominador());
    n = (numerador() / l) * (b.denominador() / k);
    d = (denominador() / k) * (b.numerador() / l);
    return *this;
}

inline Racional& Racional::operator /= (int i) {
    if(i == 0) {
        cerr << "Erro: divisão por zero!" << endl;
        exit(1);
    }
    int l = mdc(numerador(), i);
    n /= l;
    d *= i / l;
    return *this;
}

inline Racional operator / (int i, Racional a) {
    if(a.numerador() == 0) {
        cerr << "Erro: divisão por zero!" << endl;
        exit(1);
    }
    int l = mdc(a.numerador(), i);
    a.d = a.numerador() / l;
    a.n = a.denominador() * (i / l);
    return a;
}

inline Racional operator + (Racional a, Racional b) {
    return a += b;
}

inline Racional operator + (Racional a, int i) {
    return a += i;
}

inline Racional operator + (int i, Racional a) {
    return a + i;
}

inline Racional& operator + (Racional a) {
    return a;
}

inline Racional operator ++ (Racional& a, int) {
    Racional r = a;
    ++a;
    return r;
}

inline Racional operator - (Racional a, Racional b) {
    return a -= b;
}

inline Racional operator - (Racional a, int i) {
    return a -= i;
}

inline Racional operator - (int i, Racional a) {
    return -(a - i);
}

inline Racional operator -- (Racional& a, int) {
    Racional r = a;
    --a;
    return r;
}

inline Racional operator * (Racional a, Racional b) {
    return a *= b;
}

inline Racional operator * (Racional a, int i) {
    return a *= i;
}

inline Racional operator * (int i, Racional a) {
    return a * i;
}

inline Racional operator / (Racional a, Racional b) {
    return a /= b;
}

inline Racional operator / (Racional a, int i) {
    return a /= i;
}

inline bool operator == (Racional a, Racional b) {
    return a.numerador() == b.numerador() &&
           a.denominador() == b.denominador();
}

inline bool operator == (Racional a, int i) {
    return a.numerador() == i && a.denominador() == 1;
}

inline bool operator == (int i, Racional a) {
    return a == i;
}

inline bool operator != (Racional a, Racional b) {
    return !(a == b);
}

inline bool operator != (Racional a, int i) {
    return !(a == i);
}

inline bool operator != (int i, Racional a) {
    return !(i == a);
}

inline bool operator < (Racional a, Racional b) {
    int l = mdc(a.numerador(), b.numerador());
    int k = mdc(a.denominador(), b.denominador());
    return (a.numerador() / l) * (b.denominador() / k) <
           (b.numerador() / l) * (a.denominador() / k);
}

inline bool operator < (Racional a, int i) {
    int l = mdc(a.numerador(), i);
    return (a.numerador() / l) < (i / l) * a.denominador();
}

inline bool operator < (int i, Racional a) {
    int l = mdc(a.numerador(), i);
    return (i / l) * a.denominador() < (a.numerador() / l);
}

inline bool operator >= (Racional a, Racional b) {
    return !(a < b);
}

inline bool operator >= (Racional a, int i) {
    return !(a < i);
}

inline bool operator >= (int i, Racional a) {
    return !(i < a);
}

inline bool operator > (Racional a, Racional b) {
    return b < a;
}

inline bool operator > (Racional a, int i) {
    return i < a;
}

inline bool operator > (int i, Racional a) {
    return a < i;
}

inline bool operator <= (Racional a, Racional b) {
    return b >= a;
}

inline bool operator <= (Racional a, int i) {
    return i >= a;
}

inline bool operator <= (int i, Racional a) {
    return a >= i;
}

inline ostream& operator << (ostream& out, Racional r) {
    return cout << r.numerador() << '/' << r.denominador();
}

istream& operator >> (istream& in, Racional& r)
{
    int n;
    if(!(in >> n))
        return in;
    char c;
    if(!in.get(c))
    {
        r = Racional(n, 1);
        return in;
    }
    if(c == '/') {
        int d;
        if(!(in >> d))
            return in;
        r = Racional(n, d);
        return in;
    }
    in.putback(c);
    r = Racional(n, 1);
    return in;
}

Racional raizQuadrada(Racional v)
{
    const Racional tol(1, 100);
    Racional r = v;
    Racional diff;
    do {
        diff = (r - v / r) / 2;
        r -= diff;
    } while(diff >= tol || diff <= -tol);
    return r;
}

int main()
{
    cout << raizQuadrada(Racional(2)) << endl;
}

6.4.10  Exercícios

2.  Construir uma classe Mapa que guarde cadeias de caracteres e inteiros associados.  Cada cadeia de caracteres só pode ocorrer uma única vez.  Esta classe poderia servir para guardar nomes de variáveis e os respectivos valores numa calculadora escrita em C++.  Antes de escrever qualquer código em C++ pense nas operações que devem ser suportadas.  Escreva um pequeno programa que faça uso da classe desenvolvida.

3.  Refaça a classe PilhaInt de modo a usar um vector<int> em vez de uma matriz (array) de int.  Flexibilize a classe permitindo ao utilizador especificar o tamanho máximo da pilha aquando da sua criação.  Veja a Secção 7.1.

4.  Refaça o exercício anterior de modo a não se ter de impor qualquer limite às pilhas criadas.

6.5  Referências

[2]  Bjarne Stroustrup, "The C++ Programming Language", terceira edição, Addison-Wesley, Reading, Massachusetts, 1998.