1. Herança

A herança é um mecanismo que permite a uma dada classe (classe derivada -

subclasse) aceder a dados e métodos de uma outra classe (classe base -
superclasse). A utilização de herança aplica -se de uma forma natural a todos os
procedimentos definidos de uma forma hierárquica, onde as classes derivadas herdam as
propriedades da(s) classe(s) base(s).

O processo da criação de uma classe derivada, permite:

• Especialização: criação de uma classe especifica de uma dada classe, como por
exemplo a defini ão de uma classe para vectores de números inteiros com base na
classe genérica vector.

• Generalização: criação de uma classe que prolonga o comportamento da classe base

(oposto a especialização).

• Extensão: A classe derivada introduz novas funcionalidades à classe base, mas não
altera as existentes.

• Limitação: A classe derivada restringe as funcionalidades de uma classe base, como

por exemplo restringir as funcionalidade da classe vector por forma a implementar só
as funcionalidades pretendidas.

• Combinação: Utilização de herança múltipla por forma a criar novas classes de alto
nível.

Visibilidade externa de uma classe:

class TESTE
{public: // Pode ser acedido por qualquer função
int f();
int x;
protected: // Pode ser acedido por qualquer função membro,
// função amiga ou classes derivadas;
int g();
int y;
private: // Só pode ser acedido pelas funções membro da
// própria classe ou por funções membro amigas
int h();
int z;
};
A parte protected: da classe permite:
• Definição de variáveis e métodos po r forma a melhorar o acesso à classe base, por
parte da classe derivada.
• Obter uma maior eficiência no acesso à classe base.
"!#$
%'&
)(*#+%, -+'.. (/01&
32
 45678
97 :;<=> 5?5@A> B; => 7

1.1. Herança Simples

class BASE
{public:
int x;
protected:
int y;
int h(int a);
private:
int z;
};

class NATO: public BASE

{public:
int f() { return(x + BASE::x + y);
int g() { return( h() ); }
private:
int x;
};

ou

class NATO: private BASE

{public:
int f() { return(x + BASE::x + y);
int g() { return( h() ); }
private:
int x;
};

class NATO: public BASE

Todos os membros public e protected da classe BASE são membros
public e protected da classe NATO
Todos os membros private da classe BASE não podem ser acedidos pela classe NATO.

class NATO: private BASE

Todos os membros public e protected da classe BASE são membros
private da classe NATO
Todos os membros private da classe BASE não podem ser acedidos pela classe NATO.

C;8D"E#7D$58%?'F5)G*6#H%D,67<79IH'JJ GKD;807LF5 M

 NOPQR
SQ TUVWX OYOZ[X \U WX Q

1.2. Herança Múltipla

class BASE1 class BASE2 class BASE3

{ { {
public: public: public:
int x; int y; int z;
}; }; };

class NATO: public BASE1, public BASE2, public BASE3

{
public:
void f() { return(BASE1::x+BASE2::y+BASE3::z);
};

A Ordem de Derivação é Importante?

É importante para a inicialização (por omissão) das variáveis das classes bases e
derivadas (ver inicialização de construtores).

Pode-se especificar varias vezes uma classe base numa classe derivada?
Não. Não se pode especificar mais de uma vez como classe básica de uma classe
derivada, uma vez que uma referência à classe base seria ambígua.

class NATO: public BASE1, public BASE1 // erro

{
public:
void f() { return(BASE1::x+BASE2::y+BASE3::z);
};

]UR^"_#Q^$OR%Y'`O)a*P#b%^,PQVQScb'dd ae^UR0Qf`O g

 hijkl
mk nopqr isitur vo qr k

Considere o seguinte conjunto de classe bases e derivadas, utilizando herança simples e

múltipla.

class L class A: public L class B: public L

{ { {
public: public: public:
int x; int y; int z;
}; }; };

class C: public A, public B

{
public:
int f() { return(A::y + A::L::x + B::z + B::L::x + y + z); }
};

Em problemas onde existam diversas herança, por vezes torna-se mais fácil visualizar a
interligação destas classes, através da utilização de um esquema representativo da
interligação (herança) entre as classes.

Visualização da herança para melhor compreender heranças

complicadas

Como aceder à variável “x“ da classe “L“ pertencente à classe “A“?

int main()
{
C derivada;
derivada::A::x = 1; // aceder à variável “x“ da classe “L“ da classe “A“
derivada::B::x = 2; // aceder à variável “x“ da classe “L“ da classe “B“
}

wolx"y#kx$il%s'zi){*j#|%x,jkpkm}|'~~ {xol0k€‚zi €