Linguagem de Linguagem de Programação IProgramação IProgramação IProgramação I
Carlos Eduardo Batista
Centro de Informática - [email protected]
� 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 - [email protected]