1  Resumo da matéria

1.1  Notas sobre const em referências e ponteiros

typedef int* Item;

void f(const Item& i) {
    i++;    // erro!
    (*i)++; // ok!
}

void g(const int* p) {
    f(p); // erro!
}

Finalmente, a invocação de f() a partir de g() é uma erro, dado que implica a inicialização de uma referência constante para int* (a referência i parâmetro de f()) a partir de um const int*, o que descarta o const, sendo esta operação proibida pelo C++!

1.2  Herança: derivação de classes

Esta relação é um é extremamente importante e deve ser claramente distinguida da relação tem um (ou é parte de).  Por exemplo, é claro que uma moeda (no sentido físico do termo, uma chapa metálica) tem uma nacionalidade, tal como tem um valor.  Mas uma moeda, na mesma acepção, não é uma nacionalidade, tal como não é um valor.  O mesmo se passa, por exemplo, com uma turma duma universidade.  Uma turma tem um conjunto de alunos, tal como tem um nome, um delegado, etc.  Uma turma não é simplesmente um conjunto (ou lista) de alunos.  Esta diferença deve ser estabelecida mesmo em casos em que as classes identificadas parecem ter apenas um item de informação.  No âmbito dum projecto, por exemplo, as tarefas podem consistir inicialmente apenas numa duração.  Mas isso não significa que uma tarefa é uma duração.  Uma tarefa tem uma duração, tal como poderá vir a ter outros tipos de informação no futuro.

Como se representam relações é um em C++? O que se ganha com esse tipo de relação?  É o assunto da próxima secção.

1.2.1  Herança pública: relação é um

1. Usa-se uma única classe Empregado, admitindo-se que empregados com nível de chefia zero (0) são empregados normais.
2. Usam-se duas classes.

A utilização de várias classes parece portanto ser melhor solução.  Seja então a classe Empregado*:

class Empregado {
    std::string nome_;
    std::string morada_;
    Sexo sexo_;
  public:
    Empregado(std::string n, std::string m, Sexo s)
        : nome_(n), morada_(m), sexo_(s) {
    }
    std::string nome() const {
        return nome_;
    }
    std::string morada() const {
        return morada_;
    }
    Sexo sexo() const {
        return sexo_;
    }
    void mostra() const {
        std::cout << "Nome: " << nome() << std::endl
                  << "Morada: " << morada() << std::endl
                  << "Sexo: " << sexo() << std::endl;
    }
};

class Chefe {
    std::string nome_;
    std::string morada_;
    Sexo sexo_;
    int nível_;
  public:
    Chefe(std::string n, std::string m, Sexo s, int ní)
        : nome_(n), morada_(m), sexo_(s), nível_(ní) {
    }
    std::string nome() const {
        return nome_;
    }
    std::string morada() const {
        return morada_;
    }
    Sexo sexo() const {
        return sexo_;
    }
    int nível() const {
        return nível_;
    }
    void mostra() const {
        std::cout << "Nome: " << nome() << std::endl
                  << "Morada: " << morada() << std::endl
                  << "Sexo: " << sexo() << std::endl
                  << "Nível: " << nível() << std::endl;
    }
};

O segundo problema é que não há qualquer tipo de relação, do ponto de vista da linguagem C++, entre as duas classes definidas.  Ou seja, não é possível tratar um chefe como se de um empregado apenas se tratasse.  Ou seja,

Chefe c("Zé", "Rua A", masculino, 2);
Empregado e = c;

Seria também desejável que se pudesse colocar o endereço duma instância da classe Chefe num ponteiro para Empregado.  Ou seja:

Chefe c("Zé", "Rua A", masculino, 2);
Empregado* pe = &c;

Chefe c("Zé", "Rua A", masculino, 2);
Empregado& re = c;

Este comportamento permitiria, por exemplo, guardar todo o pessoal da empresa numa única lista de ponteiros para Empregado.  Por exemplo, admitindo que ListaPEmpregado é uma classe de lista em que os itens são do tipo Empregado*, o seguinte código seria possível:

ListaPEmpregado pessoal;
// Inserção dos empregados:
pessoal.põeFim(new Empregado("Manela", "Rua B", feminino));
pessoal.põeFim(new Chefe("Zé", "Rua A", masculino, 2));
...
// Visualização dos empregados:
for(ListaPEmpregado::Iterador i = pessoal.primeiro();
    i != pessoal.fim();
    ++i)
    i.item()->mostra();

* Assume-se definido um tipo enumerado Sexo e respectivo operador de escrita num canal:

enum Sexo {masculino, feminino};
inline std::ostream& operator << (std::ostream& saída, Sexo s) {
    return saída << (s == masculino? "masculino" : "feminino");
}

1ª Tentativa

class Chefe {
    Empregado e;
    int nível_;
  public:
    Chefe(std::string n, std::string m, Sexo s, int ní)
        : e(n, m, s), nível_(ní) {
    }
    std::string nome() const {
        return e.nome();
    }
    std::string morada() const {
        return e.morada();
    }
    Sexo sexo() const {
        return e.sexo();
    }
    int nível() const {
        return nível_;
    }
    void mostra() const {
        e.mostra();
        std::cout << "Nível: " << nível() << std::endl;
    }
};

Este tipo de solução não é pois o mais indicado para representar relações é um, embora o seja para representar relações tem um.

2ª Tentativa

class Empregado {
    std::string nome_;
    std::string morada_;
    Sexo sexo_;
  public:
    Empregado(std::string n, std::string m, Sexo s)
        : nome_(n), morada_(m), sexo_(s) {
    }
    Empregado(const Chefe& c)
        : nome_(c.nome()), morada_(c.morada()), sexo_(c.sexo()) {
    }
    std::string nome() const {
        return nome_;
    }
    std::string morada() const {
        return morada_;
    }
    Sexo sexo() const {
        return sexo_;
    }
    void mostra() const {
        std::cout << "Nome: " << nome() << std::endl
                  << "Morada: " << morada() << std::endl
                  << "Sexo: " << sexo() << std::endl;
    }
};

Solução

class Chefe : public Empregado {
    int nível_;
  public:
    Chefe(std::string n, std::string m, Sexo s, int ní);
    int nível() const {
        return nível_;
    }
    void mostra() const;
};

...
class D : public A, public B, public C {
    ...
};

A classe derivada herda todas os membros das classes base.  No entanto, os membros privados da classe base não ficam acessíveis directamente às funções membro da classe derivada.  Isto deve-se a que proceder de outro modo "abriria a porta" da parte privada duma classe a quem quer que definisse uma classe sua derivada, violando assim o princípio do encapsulamento.

A herança ou derivação fez-se usando a palavra chave public.  Isso significa que:

1. Os membro públicos da classe base são herdados como membros públicos da classe derivada (daí que não seja necessário redefinir as funções membro nome(), morada() e sexo()).  Este facto resolve o primeiro problema identificado, pois acrescentar o número do contribuinte e respectiva função membro na classe Empregado leva à sua inclusão automática na classe Chefe.
2. Quaisquer instâncias da classe derivada são compatíveis com instâncias da classe base, o mesmo se passando com ponteiros e referências.  Este facto resolve o segundo problema identificado, sendo agora possível inserir todo o pessoal da empresa numa única lista de ponteiros para Empregado.

1. Os membros públicos da classe base são herdados como membros privados da classe derivada.
2. As instâncias da classe derivada não são compatíveis com instâncias da classe base, o mesmo se passando com ponteiros e referências.

Compatibilidade das classes

Chefe c("Zé", "Rua A", masculino, 2);
Empregado e = c;
Empregado* pe = &c;
Empregado& re = c;

Chefe* pc = static_cast<Chefe*>(pe);
Chefe& rc = static_cast<Chefe&>(re);

Construtores, construtores por omissão e cópia e atribuição por cópia

    inline Chefe::Chefe(std::string n, std::string m,
                        Sexo s, int ní)
        : Empregado(n, m, s), nível_(ní) {
    }

A ordem pela qual as inicializações têm lugar é a que se segue:

1. Primeiro são inicializadas as classes base, por ordem de aparecimento na especificação das heranças na definição da classe derivada, através da invocação dos respectivos construtores.
2. Depois são inicializadas as variáveis e constantes membro de instância da classe derivada, por ordem de declaração, através da invocação dos respectivos construtores.
3. Finalmente é executado o corpo do construtor.

class Z {
    ...
};
class D : A, B, C {
    static const int dim = 10;
    int i;
    const Z z;
    float m[dim];
    int* pi;
  public:
    D(int ii, const Z& zz) : i(ii), z(zz) {
        for(int i = 0; i != dim; ++i)
            m[i] = 0;
        pi = new int;
    }
    ~D() {
        delete pi;
    }
    ...
};

1. Construtor de A, para inicialização das variáveis membro herdadas de A.
2. Construtor de B, para inicialização das variáveis membro herdadas de B.
3. Construtor de C, para inicialização das variáveis membro herdadas de C.
4. Construtor de int, para inicialização da variável membro i.
5. Construtor de Z, para inicialização da constante membro z.
6. m e pi, sendo derivadas de tipos básicos, não têm quaisquer construtores invocados.
7. Corpo do construtor, onde se inicializa a matriz m e se cria uma variável dinâmica cujo endereço se guarda na variável membro pi.

Como para qualquer outra classe, o compilador tentará sempre criar automaticamente um construtor por omissão (se não se tiver definido qualquer construtor na classe), que invoca os construtores por omissão de todas as classe base, um construtor por cópia (desde que não seja definido explicitamente na classe), que invoca os construtores por cópia das classe base, e um operador de atribuição por cópia (desde que não seja definido explicitamente na classe), que invocará os operadores de atribuição por cópia das classes base.

De igual forma é criado automaticamente um destrutor (desde que não seja definido explicitamente) que invoca os destrutores das classes base.  A ordem pela qual as operações ocorrem é a seguinte:

1. Primeiro é executado o corpo do destrutor.
2. Depois são invocados os destrutores das variáveis e constantes membro de instância da classe base, por ordem inversa de declaração.
3. Finalmente são invocados os destrutores das classe base por ordem inversa à do seu aparecimento na especificação das heranças na definição da classe derivada.

1. Corpo do destrutor, onde se devolve à memória livre a variável dinâmica cujo endereço se guarda em pi.
2. m e pi, sendo derivadas de tipos básicos, não têm quaisquer destrutores invocados.
3. Destrutor de Z, para a constante membro z.
4. Destrutor de C, para as variáveis membro herdadas de C.
5. Destrutor de B, para as variáveis membro herdadas de B.
6. Destrutor de A, para as variáveis membro herdadas de A.

Sobreposição

    void Chefe::mostra() const {
        Empregado::mostra();
        std::cout << "Nível: " << nível() << std::endl;
    }

Dada a definição da classe, o seguinte código

Chefe c("Zé", "Rua A", masculino, 2);
c.mostra();

Nome: Zé
Morada: Rua A
Sexo: masculino
Nível: 2

c.Empregado::mostra();

Nome: Zé
Morada: Rua A
Sexo: masculino

Hierarquias de classes

class SerVivo {
    ...
};
class Animal /* reino */ : public SerVivo {
    ...
};
class Vegetal /* reino */ : public SerVivo {
    ...
};
class Cordado /* filo */ : public Animal {
    ...
};
class Vertebrado /* subfilo */ : public Cordado {
    ...
};
class Mamífero /* classe */ : public Vertebrado {
    ...
};
class Primata /* ordem */ : public Mamífero {
    ...
};
class Hominídeo /* família */ : public Primata {
    ...
};
class Homo /* género */ : public Hominídeo {
    ...
};
class Homo_sapiens /* espécie */ : public Homo {
    ...
};
class Homo_sapien_sapiens /* subespécie */
    : public Homo_sapiens {
    ...
};

Problemas

ListaPEmpregado pessoal;
// Inserção dos empregados:
pessoal.põeFim(new Empregado("Manela", "Rua B", feminino));
pessoal.põeFim(new Chefe("Zé", "Rua A", masculino, 2));
...
// Visualização dos empregados:
for(ListaPEmpregado::Iterador i = pessoal.primeiro();
    i != pessoal.fim();
    ++i)
    i.item()->mostra();

1.2.2  Herança privada: redução/alteração de interfaces

Suponha-se que se pretende, mais uma vez, implementar o conceito de pilha de inteiros, na forma da classe PilhaInt, mas agora sem quaisquer limitações quanto ao número de itens, excepto a memória disponível.  Uma vez que a classe ListaInt está já desenvolvida, não impões restrições quanto ao comprimento das listas, e possui todos os métodos necessários para implementar uma pilha, é natural pensar em implementar o conceito de pilha com base na implementação das listas já existentes.

Admita-se que a classe ListaInt, definida na Aula 5, Secção 1.3, possuia os seguintes métodos adicionais:

• bool vazia() - devolve true se a lista estiver vazia.
• Item& frente() - devolve referência para o primeiro item da lista.
• Item frente() const - devolve cópia do primeiro item da lista (para listas constantes).
• Item& trás() - devolve referência para o último item da lista.
• Item trás() const - devolve cópia do último item da lista (para listas constantes).

class PilhaInt {
    ListaInt l;
  public:
    typedef ListaInt::Item Item;
    void põe(Item item) {
        l.põeFim(item);
    }
    void tira() {
        l.tiraÚltimo();
    }
    Item topo() const {
        return l.trás();
    }
    Item& topo() {
        return l.trás();
    }
    bool vazia() const {
        return l.vazia();
    }
    int altura() const {
        return l.comprimento();
    }
};

class PilhaInt : private ListaInt {
  public:
    typedef ListaInt::Item Item;
    void põe(Item item) {
        põeFim(item);
    }
    void tira() {
        tiraÚltimo();
    }
    Item topo() const {
        return trás();
    }
    Item& topo() {
        return trás();
    }
    bool vazia() const {
        return ListaInt::vazia();
    }
    int altura() const {
        return comprimento();
    }
};

Esta solução pode ser vista como um alteração da interface da classe ListaInt de modo a proporcionar os serviços de uma pilha.

O C++ proporciona uma forma simples de abrir excepções quanto ao tipo de herança.  Se se pretender tornar públicos membros cuja herança foi feita duma forma privada, basta usar uma declaração de utilização do respectivo nome na parte pública da classe derivada.  Assim, a classe PilhaInt poderia ser definida como:

class PilhaInt : private ListaInt {
  public:
    using ListaInt::Item;
    void põe(Item item) {
        põeFim(item);
    }
    void tira() {
        tiraÚltimo();
    }
    Item topo() const {
        return trás();
    }
    Item& topo() {
        return trás();
    }
    using ListaInt::vazia;
    int altura() const {
        return comprimento();
    }
};

Note-se que usar herança pública neste caso seria o mesmo que afirmar que um pilha é uma lista, o que manifestamente não é verdade.  Note-se ainda que, se se considerarem os nomes usados na lista como apropriados para a pilha, pode-se fazer simplesmente:

class PilhaInt : private ListaInt {
  public:
    using ListaInt::Item;
    using ListaInt::põeFim;
    using ListaInt::tiraÚltimo;
    using ListaInt::trás;
    using ListaInt::vazia;
    using ListaInt::comprimento;
};

1.2.3  Políticas de acesso

1. Se um membro duma classe é privado, só lhe podem aceder membros ou amigos dessa mesma classe.
2. Se um membro duma classe é público, o acesso não tem restrições.
3. Os membros públicos duma classe estão sempre acessíveis a membros e amigos de qualquer classe derivada.
4. Os membros públicos duma classe só são acessíveis por intermédio de instâncias de uma classe derivada se essa derivação se tiver feito duma forma pública (herança pública).

class A {
  private:
    int i;
  public:
    int u;
};

class B : private A {
  public:
    void f() {
        i = 1; // erro: i é privada de A.
        u = 1;
    }
};

class C : public A {
  public:
    void f() {
        i = 1; // erro: i é privada de A.
        u = 1;
    }
};

void g() {
    A a;
    B b;
    C c;

    a.i = 1; // erro: i é privada de A.
    a.u = 1;
    b.i = 1; // erro: i é privada de A.
    b.i = 1; // erro: i é privada de B (herança privada).
    c.i = 1; // erro: i é privada de A.
    c.u = 1;

    a = b; // erro: um B não é um A (herança privada).
    b = a; // erro: um A não é um B.
    a = c;
    c = a; // erro: um A não é um C.
}

1.3  Leitura recomendada

2  Exercícios

• bool vazia() - devolve true se a lista estiver vazia.
• Item& frente() - devolve referência para o primeiro item da lista.
• Item frente() const - devolve cópia do primeiro item da lista (para listas constantes).
• Item& trás() - devolve referência para o último item da lista.
• Item trás() const - devolve cópia do último item da lista (para listas constantes).

3  Referências

[2]  Bjarne Stroustrup, "The C++ Programming Language", 3ª edição, Addison-Wesley, Reading, Massachusetts, 1997. *

# Existem 10 exemplares na biblioteca do ISCTE.

* Existe um exemplar na biblioteca do ISCTE.