Linguagem de Linguagem de Programação IProgramação IProgramação IProgramação I

Carlos Eduardo Batista

Centro de Informática - UFPBbidu@ci.ufpb.br

� Herança e composição em C++

C++ e POOC++ e POO2

Carro

private:String modelo;String chassis;Motor m;

public:liga();

EncapsulamentoEncapsulamento3

liga();acelera(int);freia(int);private:liberaCombustivel(int);freioABS(int);

� Hierarquia de classes

� Classes mais especializadas herdam das mais genéricas

� Atributos e métodos são herdados

� Classe filha é um “tipo de” Classe Pai

HerançaHerança4

� Herança simples

� Composição

� Combinando composição e herança

� Herança múltipla (!!!)

� Polimorfismo e funções virtuais

� Classes abstratas

Herança e composiçãoHerança e composição5

� Vantagem: mecanismos para reuso de código

� Herança e composição: diferentes formas de se utilizar ‘blocos’ de código ◦ Mais possibilidades que as oferecidas por linguagens procedurais

� Herança versus composição

Herança e composiçãoHerança e composição

� Herança versus composição

6

Polígono

Cor c;

desenhar();apagar();definirCor(Cor c);area();

Retângulo Triângulo

HerançaHerança7

Retângulo

desenhar();apagar();area();

desenhar();apagar();area();

Círculo

desenhar();apagar();area();

Carro

private:String modelo;String chassis;Motor m;SistemaFreio f;

public:

ComposiçãoComposição8

public:liga();acelera(int);freia(int);private:liberaCombustivel(int);freioABS(int);

� X “é um tipo de” Y◦ Cachorro é um tipo de mamífero

◦ Mamífero é um tipo de animal

◦ Ave é um tipo de animal

� Interface comum entre subclasses de uma mesma classe

Herança simplesHerança simples9

Animal

int idade;

come()dorme()

Ave

botaOvo()

Mamífero

mama()

Herança simplesHerança simples10

Cachorro

late()morde()

Curió

canta()voa()

� Atributos privados da classe base (pai) não são acessíveis nas subclasses (filhas)◦ Acesso indireto através de funções públicas das

classes base

� Herança pública◦ class Y : public X {};

� Métodos públicos de X também serão públicos em Y

� Y tem a mesma interface de X

Herança simplesHerança simples

� Y tem a mesma interface de X

� Y é um tipo de X

� Herança privada◦ class Y : X { };

� O que era público em X é privado em Y

� Y não é um tipo de X

11

� Métodos herdados podem ser sobrescritos

class Animal {int idade;

public:Animal(int id) :idade(id) {}void come();void dorme();

};

Herança simplesHerança simples12

};class Ave: public Animal {

string nome;public:

Ave(int, const string&);void dorme();

};

� Utilização de objetos de classes existentescomo membros (atributos) de outrasclasses◦ A nova classe é composta de objetos de classes existentes Carro

Motor m;SistemaFreio f;Roda r[4];

ComposiçãoComposição13

Roda r[4];

anda()para()

Motor

acelera()

Roda

gira()

SistemaFreio

freia()

4

1

1

class Roda { };class Motor { };class SistemaFreio { };class Carro {vector <Roda> r;Motor m;SistemaFreio f;

ComposiçãoComposição14

SistemaFreio f;public: ...};

� Inicialização dos objetos é feita no construtor da classe que os contém

class Roda {double raio;

public:Roda(double r) : raio(r) {}

};

class Motor {double pot;

public:

class Carro {vector<Roda> rodas;Motor mot;SistemaFreio fre;

public:Carro (double r, double p, int n)

: rodas(4, Roda(r)) , mot(p), fre(n) {}};

ComposiçãoComposição15

public:Motor(double p): pot (p) { }

};

class SistemaFreio {int numSerie;

public:SistemaFreio(int n): numSerie(n) { }

};

int main() {Carro c1(10., 20., 234225);return 0;

}

� Novas classes podem ser formadasutilizando composição e herançaclass A {int i;

public:A(int ii) : i(ii) {}~A() {}void f() const {}

};

class C : public B {A a;

public:C(int ii) : B(ii), a(ii) {}~C() {} // chama ~B e ~Avoid f() const {

ComposiçãoComposição16

};class B {int i;

public:B(int ii) : i(ii) {}~B() {}void f() const {}

};

void f() const {a.f();B::f(); }};int main() {C c(47); }

� Quando objetos das classes derivadasdeixam seu escopo, os métodosdestrutores são chamados ao longo da hierarquia◦ Ordem inversa à ordem dos construtores

OrdemOrdem de de chamadachamada de de destrutoresdestrutores17

� Ambas permitem reuso de código� Herança

◦ Características da classe base estão na interface da classe filha

◦ Classe filha é tipo da classe base� Subtipagem

� Composição◦ Classe contém as características das classes

HerançaHerança e/e/ouou composiçãocomposição

◦ Classe contém as características das classes utilizadas na composicão

◦ Essas características geralmente não aparecem na interface� Só se membro for público

18

� Herança privada◦ o que era público na classe base passa a ser privado na classe derivada

◦ A classe derivada é implementada em termos da classe base, e não é um tipo da classe base

◦ Pode-se expor alguns nomes na interface pública utilizando-se a palavra chave using

19

class Pet {public:

char eat() const { return 'a'; }int speak() const { return 2; }float sleep() const { return 3.0; }float sleep(int) const { return 4.0; }

};class Goldfish : Pet { // Private inheritancepublic:

using Pet::eat; // Name publicizes memberusing Pet::sleep; // Both overloaded members expose d

};int main() {

HerançaHerança privadaprivada20

Goldfish bob;bob.eat();bob.sleep();bob.sleep(1);

//! bob.speak();// Error: private}

� Especificadores de acesso◦ public

◦ private

◦ protected

� Herança◦ Algo privado para os usuários da classe, mas acessível para os membros da própria

AtributosAtributos protegidosprotegidos

mas acessível para os membros da própriaclasse e de suas classes derivadas� Encapsulamento protected

21

include <fstream>using namespace std;class Base {

int i;protected:int read() const { return i; }

void set(int ii) { i = ii; }public:

Base(int ii = 0) : i(ii) {}int value(int m) const { return m*i; }

};

class Derived : public Base {int j;

AtributosAtributos protegidosprotegidos22

int j;public:

Derived(int jj = 0) : j(jj) {}void change(int x) { set(x); }

};int main() {Derived d;

d.change(10);}

� Implementar hierarquia de classes exibidano diagrama do slide 13◦ Usar composição

◦ Usar herança (incrementar)

◦ Usar encapsulamento protected

ExercícioExercício emem salasala23

� Herança e composição em C++ (continuação)

Próxima aulaPróxima aula24

� Notas de aula do Prof. Renato Maia (Unimontes)

� Notas de aula do Prof. Renato Mesquita (UFMG)

ReferênciasReferências25

Linguagem de Linguagem de Programação IProgramação IProgramação IProgramação I

Carlos Eduardo Batista

Centro de Informática - UFPBbidu@ci.ufpb.br