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

Carlos Eduardo Batista

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

� Fundamentação de Orientação a Objetos (OO).

� Modelagem de sistemas orientada a objetos usando C++

� Modelagem de sistemas orientada a objetos.

� Conceitos básicos de Análise e Projeto

C++ e POOC++ e POO

� Conceitos básicos de Análise e Projeto Orientado a Objetos utilizando a UML (Unified Modeling Language).

2

� O que é um Objeto (em linguagens como C++)◦ É uma variável que� Armazena dados estruturados (como TADs)� Possui operações (funções) associadas

� Objetos◦ Atributos

Orientação a ObjetosOrientação a Objetos

◦ Atributos� Dados

◦ Métodos� Funções

� Classes◦ Definem características comuns dos objetos

� Estados dos objetos◦ Valores dos atributos individuais

� Cada objeto pertence a uma classe, que define seu comportamento e suas característicasConjunto de métodos de um objeto =

Orientação a ObjetosOrientação a Objetos

� Conjunto de métodos de um objeto = interface◦ Encapsulamento define a visibilidade

4

Carro

private:String modelo;String chassis;Motor m;public:liga();

EncapsulamentoEncapsulamento5

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ça6

class Animal {int idade;

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

};class Ave: public Animal {

string nome;public:

HerançaHerança7

Ave(int, const string&);void voa();void botaOvo();

};

int main() {Ave A(2, “Patativa”);Animal B(3);A.come();A.dorme();

HerançaHerança8

B.come();B.dorme();A.voa();A.botaOvo();

}

class Animal {int idade;

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

};class Ave: public Animal {

HerançaHerança9

class Ave: public Animal {string nome;

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

};

int main() {Ave A(2, “Patativa”);Animal B(3);A.come(); // chama Animal::come()A.dorme(); // chama Ave::dorme()B.come(); // Animal::come()B.dorme (); // Animal::dorme()

HerançaHerança10

B.dorme (); // Animal::dorme()}

� C++ oferece mecanismos para automatizar a inicialização e a finalização de objetos◦ Alocação e liberação dos recursos◦ Métodos construtores e destrutores

Ciclo de vida de objetosCiclo de vida de objetos11

� Métodos construtores◦ Mesmo nome da classe◦ Chamada automática na declaração◦ Pode receber parâmetros� Polimorfismo se aplica

Ciclo de vida de objetosCiclo de vida de objetos12

class CoisaX {int i;public:

CoisaX();};

Ciclo de vida de objetosCiclo de vida de objetos13

void f() {CoisaX a;

}

class Pessoa {int idade;public:Pessoa(int i);

};

Pessoa::Pessoa(int i) {idade = i;

}

Ciclo de vida de objetosCiclo de vida de objetos14

}

void f() {Pessoa a(18);

// ...}

� Método destrutor◦ Função chamada sempre que o escopo de um objeto se encerra

◦ Cada classe só pode ter um método destrutor◦ Método destrutor não recebe parâmetros� Nem retorna nada

Ciclo de vida de objetosCiclo de vida de objetos15

class Coisa {public:~Coisa();

};

class Pessoa {int idade;

public:Pessoa(int i); // Constructor~Pessoa();// Destructorvoid setIdade(int i);int getIdade();

};

Pessoa::Pessoa(int i) {idade = i;

}

Pessoa::~Pessoa() {

Ciclo de vida de objetosCiclo de vida de objetos16

cout << "Destrutor" << endl;}

void Pessoa::setIdade(int i) {idade = i;

}

int Pessoa::getIdade() {return idade;

}

class Ponto {private:

int x, y;public:

Ponto();Ponto(int, int);

};

Ponto::Ponto(int xx, int yy) {x = xx;y = yy ;

Sobrecarga de funçõesSobrecarga de funções17

y = yy ;}

Ponto::Ponto() {x = 0;y = 0;

}

int main() {Ponto A, B(3, 4);Ponto *p = new Ponto(3, 4);Ponto *p1 = new Ponto;

Sobrecarga de funçõesSobrecarga de funções18

Ponto *p1 = new Ponto;Ponto Vpoints[10];

...}

class Ponto {private:

int x, y;public:

Ponto(int = 0, int = 0); //Valores default};

Ponto::Ponto(int xx, int yy) {x = xx;

Sobrecarga de funçõesSobrecarga de funções19

y = yy;}

� Compilador expande de forma similar as macros◦ Não há garantia que cada chamada seja realmente inline

� Funções pequenas ◦ Ex. acesso a atributos

Class Exemplo {

Funções Funções inlineinline20

Class Exemplo {int i;

public:int get() const { return i; }void set(inti i) { i = ii; }

};

Class Retangulo {int larg, alt;

public:Rectangulo(int l = 0, int a = 0) : larg(l), alt(a) {}int largura() const{ return larg; } void largura(int l) { larg = l; } int altura() const{ return altura; } void altura(int a) { alt = a; }

};int main () {

Funções Funções inlineinline21

int main () {Retangulo r(19, 47);r.altura(2 * r.largura());r.largura(2 * r.altura());

} ///:~

class Rectangle {int width, height;

public:Rectangle(int w = 0, int h = 0);int getWidth() const;void setWidth(int w);int getHeight() const;void setHeight(int h);

};inline Rectangle::Rectangle(int w, int h) :

width(w), height(h) {}inline int Rectangle::getWidth() const {

return width ;

Funções Funções inlineinline22

}inline void Rectangle::setWidth(int w) {

width = w;}inline int Rectangle::getHeight() const {

return height;}inline void Rectangle::setHeight(int h) {

height = h;}

� Inicializadas na primeira vez em que o programa realiza a declaração da variável

� Valor é mantido de uma chamada para outra◦ Área de variáveis estáticas do programa (não são criadas na pilha)

int count () {

Variáveis Variáveis staticstatic23

int count () {static int num = 0;int x = 0; num++;return num;

}

� Construtor chamado apenas uma vez◦ No momento em que a thread de execução do programa executa pela primeira vez o código da função que instancia o objeto

� O destrutor de um objeto static somente é executado ao término do programa

� Objeto global

Objetos Objetos staticstatic

� Objeto global◦ Construtor chamado antes do main()◦ Destrutor chamado ao término do programa

24

#include <iostream>using namespace std;class Obj {

char c; // Identifierpublic:

Obj(char cc) :c(cc) {

cout << "Obj::Obj() for " << c << endl;}~Obj() {

cout << "Obj::~Obj() for " << c << endl;}

};

Objetos Objetos staticstatic25

Obj a('a'); // Globalvoid f() {

static Obj b('b');}void g() {

static Obj c('c');}

int main() {cout << "inside main()" << endl;f(); // Calls static constructor for b// g() not called, c not constructedcout << " leaving main ()" << endl ;

Objetos Objetos staticstatic26

cout << " leaving main ()" << endl ;} ///:~

� Implementam conceito de atributos de classe◦ Todos os objetos de uma classe compartilham os atributos estáticos

class Ponto{int x, y; static int cont;

// ...

Atributos Atributos staticstatic27

// ...};

Ponto Ponto_1, Ponto_2;

� Acesso definido por encapsulamento◦ Funções membro podem acessar, outras partes se público

� Atributos estáticos podem ser acessados antes da instanciação de qualquer objeto da classe◦ Espaço de memória reservado antes da instanciação de qualquer objeto

Atributos Atributos staticstatic

instanciação de qualquer objeto� Somente constantes estáticas podem ser

definidas na declaração de uma classe◦ Atributos estáticos devem ser redeclaradas no escopo da classe

28

class Ponto{int x, y;static int cont;

// ....};

int Ponto :: cont = 7;

Atributos Atributos staticstatic29

class Buffer {static const int buffsize = 256;char buff[buffsize];

// ...};

� Funções membro que ◦ Podem ser chamadas através da classe, e não de uma instância particular

◦ Não podem manipular membros não estáticos da classe � Só manipulam atributo estáticos!

class Ponto{int x, y;

Métodos Métodos staticstatic30

int x, y; static int cont;static int getCont() { return cont; }

};int Ponto::cont = 0;int main() {

cout << “Cont: “<<Ponto::getCont()<<endl;return 0;

}

� Classe que possui apenas uma instância� Instância disponível globalmente no

código� Há várias situações que uma classe pode

ter apenas uma instância◦ Recursos escassos (interface de rede, spool de impressão) , Gerenciador de propriedades de um sistema etc.

Padrão de projeto: Padrão de projeto: SingletonSingleton

um sistema etc.� Construtor privado

◦ Usa-se método static Instance()

31

class KbdBuffer {public:

char getch(); // reads from the bufferstatic KbdBuffer *Instance();

private:KbdBuffer(); // the constructorstatic KbdBuffer *instancePtr; // pointer to instance

};KbdBuffer *KBdBuffer::instancePtr = 0; // reset pointerKbdBuffer *KbdBuffer::Instance() {

Padrão de projeto Padrão de projeto -- SingletonSingleton32

if (instancePtr == 0) // if pointer is null...instancePtr = new KbdBuffer;

return(instancePtr)}Utilização: char foo = KbdBuffer::Instance() -> getch();

� Agrupamento lógico ◦ Definição de escopo associado a nomes (espaço de nomes)

◦ Declaração relacionada de variáveis, funções, classes

� Arquivos = agrupamento físico� Namespace = agrupamento lógico� A definição de um namespace pode ser

NamespacesNamespaces

� A definição de um namespace pode ser continuada em múltiplos arquivos de cabeçalho

� Não usar using nos cabeçalhos (.h)◦ Apenas nos .cpp

33

//: C10:Header1.h#ifndef HEADER1_H#define HEADER1_Hnamespace MyLib {void f();// ...}#endif // HEADER1_H ///:~//: C10:Header2.h#ifndef HEADER2_H

#include "Header1.h"// Add more names to MyLibnamespace MyLib { void g();// ...}#endif // HEADER2_H ///:~//: C10:Continuation.cpp#include "Header2.h" int main() {

MyLib ::f();

NamespacesNamespaces34

#ifndef HEADER2_H#define HEADER2_H

MyLib ::f();MyLib::g();

} ///:~

� Separação lógica ◦ Agrupamentos e entidades de alto nível na arquitetura de software

� Usa-se namespaces para evitar colisões namespace Meu {char f(char);int f(int);class String { /* ... */};

char a, c;using Seu::String;

NamespacesNamespaces35

};}namespace Seu {char f(char);double f(double);class String { /* ... */};}

using Seu::String;String d;Meu::f (c);Seu::f (a);

namespace String_dele {class String { /* ... */};}namespace Vetor_dela {class Vector {/* ... */};}namespace Minha_lib {using namespace String_dele;using namespace Vetor_dela;void minha funcao(Vector&); // declaração de função }void f() {

AninhamentoAninhamento de de namespacesnamespaces36

void f() {Minha_lib::String s = "Pixinguinha";

}using namespace Minha_lib;void g(Vector &vs) {

// ...minha_funcao(vs);

}}

namespace Int {enum sign {

positive, negative};class Integer {

int i;sign s;

public:Integer(int ii = 0) :

i(ii), s(i >= 0 ? positive : negative) {}sign getSign() const {

return s;}

NamespacesNamespaces37

void setSign(sign sgn) {s = sgn;

}// ...};}namespace Math {using namespace Int;Integer a, b;Integer divide(Integer, Integer); // ... }

� Fundamentação de Orientação a Objetos (OO).

� Modelagem de sistemas orientada a objetos usando C++

� Modelagem de sistemas orientada a objetos.

� Conceitos básicos de Análise e Projeto

Próxima aulaPróxima aula

� Conceitos básicos de Análise e Projeto Orientado a Objetos utilizando a UML (Unified Modeling Language).

38

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

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

ReferênciasReferências39

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

Carlos Eduardo Batista

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