1. Programação Orientada para Objetos com C++ José Luiz de Souza Pio UFMG Belo Horizonte – Minas Gerais Abril de 2002

15. POO Operações Estrutura de dados Dependência Mútua Como ficam as estruturas de dados globais?

16. POO Decisões de Projeto Estruturas Operações Decomposição Coloque juntas todas as decisões de projeto relacionadas

20. Objetos e Métodos OBJETO Dados Privados Métodos Métodos são formados por sua interface e implementação Variáveis locais a cada objeto Todos os elementos do sistema são representados por objetos que podem ser gerados um número arbitrário de vezes durante a execução do programa.

31. Classes, Instâncias e Mensagens Motor Cabo elétrico Disco de serra Correia Serra Elétrica Serra E létrica Martelete Furadeira Prensa

33. Classes, Instâncias e Mensagens Protocolo Parte visível Parte privada Variáveis de Instância e métodos Classe

35. Classes, Instâncias e Mensagens Bic Paker Y X 4 20 Y X 200 10 Instâncias da classe CanetaGráfica Estado interno Variáveis de instância

39. Classes, Instâncias e Mensagens Objeto 1 Dados Objeto n Dados Objeto 2 Dados Objeto 6 Dados Objeto 5 Dados Objeto 3 Dados Objeto 4 Dados

51. Herança e Polimorfismo classe B Dados B Métodos B classe C Dados B Dados C Métodos B Métodos C

52. Herança e Polimorfismo superclasse subclasses Representação gráfica para a Herança Especialização

54. Herança e Polimorfismo A herança múltipla classe A classe B classe C Dados A Métodos A Dados B Métodos B Dados A Dados B Dados C Métodos A Métodos B Métodos C

62. Classes e Objetos em C++

74. Classes e Objetos em C++ class TPessoa { protected: char* pcNome; int nIdade; public: void Anda(void); friend; } class TAnimal { protected: char* pcNome; char* pcCientNome; public: void Anda(void); } void TPessoa::Anda(void) { ... } Apesar de estar definida nas duas classes, só teremos a implementação do método Anda de TPessoa:

83. Classes e Objetos em C++ Exercícios de Implementação 1. Partidos políticos necessitam, principalmente neste período, de pesquisas que mostrem as intenções de voto do eleitor. A cidade é dividida em zonas eleitorais e você deve montar um programa que emita as estatísticas e as intenções de voto em cada zona eleitoral. Quais são as classes mais importantes que você vê para desenvolver o seu programa? Detalhe e implemente a definição de uma das classes que você idealizou em C++. 2. Crie uma classe chamada Complexos para fazer aritmética de números complexos. Escreva o programa e teste sua classe. Lembre-se que um número complexo tem a forma a+bi, onde i = sqrt(-1). Use variáveis float para representar os dados private da classe. Forneça uma função construtora para os objetos dessa classe. As funções membro devem ser as seguintes: a) Adição de dois complexos; b) Subtração de complexos; c) Impressão de complexos na forma (a, b), onde a é a parte real e b é a parte complexa. 3. Crie uma classe Retangulo. A classe tem atributos comprimento e largura, com valor default igual a 1. Forneça as funções get e set, tanto para o comprimento quanto para a altura.

84. Classes e Objetos em C++

85. Classes e Objetos em C++ //Arquivo 1 ponto.h, definicao para a classe ponto. class ponto { public: //daqui em diante tudo e acessivel. void inicializa(float a,float b); void mostra(void); private: float x; //sao ocultos por default float y; //sao ocultos por default };

86. Classes e Objetos em C++ //Arquivo 2 , ponto.cpp , implementacao para a classe ponto. #include <iostream.h> #include &quot;ponto.h&quot; void ponto::inicializa(float a,float b) { x=a; y=b; } //as funcoes de uma classe podem acessar os atributos private dela mesma. void ponto::mostra(void) {cout << &quot;X:&quot; << x << &quot; , Y:&quot; << y << endl;}

87. Classes e Objetos em C++ //Arquivo 3 . Programa principal: princ.cpp #include &quot;ponto.h&quot; void main() { ponto ap; //instanciacao ap.inicializa(0.0,0.0); //metodos public ap.mostra(); //metodos public

89. Classes e Objetos em C++ //File easyfra.h long mdc(long n,long d); //maximo divisor comum metodo de Euclides. class fracao { private: long num; //numerador long den; //denominador public: fracao(long t,long m); //construtor comum void simplifica(void); //divisao pelo mdc ~fracao() { /* nao faz nada*/ } //operacoes matematicas basicas fracao soma (fracao j); fracao multiplicacao(fracao j); //operacoes de comparacao int igual(fracao t); int diferente(fracao t); int maiorouigual(fracao t); //operacoes de input output void mostra(void); //exibe fracao no video void cria(void); //pergunta ao usuario o valor da fracao //operacoes de conversao de tipos double convertedbl(void); //converte para double long convertelng(void); //converte para long };

90. Classes e Objetos em C++ //implementacao para a classe fracao. #include <iostream.h> #include &quot;easyfra.h&quot; long mdc(long n,long d) //maximo divisor comum //metodo de Euclides . { if (n<0) n=-n; if (d<0) d=-d; while (d!=0) { long r=n % d; //%=MOD=Resto da divisao inteira. n=d; d=r; } return n; } void fracao::simplifica(void) { long commd; commd=mdc(num,den); //divisor comum num=num/commd; den=den/commd; if (den<0) { den=-den; num=-num;}; //move sinal para cima } fracao::fracao(long t,long m) { num=(t); den=(m); simplifica(); //chamada para o mesmo objeto. }

91. Classes e Objetos em C++ fracao fracao::soma(fracao j) { fracao g((num*j.den)+(j.num*den),den*j.den); return g; } fracao fracao::multiplicacao(fracao j) { fracao g(num*j.num,den*j.den); return g; } int fracao::igual(fracao t) { return ((num*t.den)==(den*t.num)); //funciona bem mesmo para nao simplificada } int fracao::diferente(fracao t) { return ((num*t.den)!=(den*t.num)); } int fracao::maiorouigual(fracao t) { return ((num*t.den)>=(t.num*den)); } void fracao::mostra(void) { cout << &quot;(&quot; << num << &quot;/&quot; << den << &quot;)&quot;; } void fracao::cria(void) { cout << &quot;Numerador:&quot;; cin >> num; cout << &quot;Denominador:&quot;; cin >> den; simplifica(); }

92. Classes e Objetos em C++ double fracao::convertedbl(void) { double dbl; dbl=(double(num)/double(den)); return dbl; } //conversao para long long fracao::convertelng(void) { long lng; lng=num/den; return lng; }

93. Classes e Objetos em C++ #include <iostream.h> #include &quot;easyfra.h&quot; //nossa definicao da classe #include <stdio.h> main() { fracao a(0,1),b(0,1); cout << &quot; Entre com fracao a: &quot;; a.cria(); a.mostra(); cout << &quot; Entre com fracao b: &quot;; b.cria(); b.mostra(); fracao c(a.soma(b)); //c(a+b) cout << endl << &quot;c de a+b:&quot;; c.mostra(); cout << endl << &quot;a*b&quot;; c=a.multiplicacao(b); c.mostra(); cout << endl << &quot;a+b&quot;; c=a.soma(b); c.mostra(); cout << endl << &quot;a>=b&quot;; cout << a.maiorouigual(b); cout << endl << &quot;a==b&quot;; cout << a.igual(b); cout << endl << &quot;a!=b&quot;; cout << a.diferente(b); cout << endl << &quot;long(a) &quot;; cout << a.convertelng(); cout << endl << &quot;double(a) &quot;; cout << a.convertedbl(); return 0; }

94. Classes e Objetos em C++ #include <iostream.h> #include <math.h> //double sqrt(double x); de math.h retorna raiz quadrada do numero //double pow(double x, double y); de math.h calcula x a potencia de y const float ZERO=0.0; class ponto{ private: float x; //sao ocultos por default nao precisaria private mas e' bom float y; //sao ocultos por default public: //daqui em diante tudo e acessivel em main. ponto(float a,float b) { x=a; y=b; } void mostra(void) const {cout << &quot;X:&quot; << x << &quot; , Y:&quot; << y << endl;} float distancia(const ponto hi) const{ return float( sqrt( ( pow(double(hi.x-x),2.0) + pow(double(hi.y-y),2.0) ) )); //teorema de Pitagoras } };

95. Classes e Objetos em C++ void main() { ponto ap(3.0,4.0); //instanciacao ap.mostra(); //funcoes membro public const ponto origem(ZERO,ZERO); //defino objeto constante origem.mostra(); cout << &quot;Distancia da origem:&quot; << origem.distancia(ap); }

97. Classes e Objetos em C++ #include <iostream.h> void main() { int* a; //declara um ponteiro para endereco de variavel inteira a=new int(3); //aloca memoria para o apontado por a, gravando neste o valor 3 cout << (*a) << endl ; //imprime o valor do apontado por a delete a; //desaloca memoria } Ponteiros em C++

98. Classes e Objetos em C++ #include <iostream.h> class vetor_tres { public: int vet[3]; //vetor alocado estaticamente numa classe. vetor_tres(int a,int b,int c) { vet[0]=a; vet[1]=b; vet[2]=c; } //construtor do vetor void mostra(void) { cout << vet[0] << &quot; &quot; << vet[1] << &quot; &quot; << vet[2] << endl;} //funcao membro para mostrar o conteudo do vetor }; Alocação Estática

99. Classes e Objetos em C++ void main() { vetor_tres v1(1,2,3); //criacao de um objeto vetor. vetor_tres v2(15,16,17); //criacao de um objeto vetor. v1.mostra(); //mostrando o conteudo de v1. v2.mostra(); //mostrando o conteudo de v2. v2=v1; //atribuindo objeto v1 ao objeto v2. v2.mostra(); //mostrando v2 alterado. v1.vet[0]=44; v1.mostra(); //mostrando o conteudo de v1. v2.mostra(); //mostrando o conteudo de v2. }

100. Classes e Objetos em C++ #include <iostream.h> //vetor alocado dinamicamente void main() { int tamanho; int* vet; cout << &quot;Entre com o tamanho do vetor a criar&quot;; cin >> tamanho; vet=new int[tamanho]; //alocando vetor de &quot;tamanho&quot; posicoes comecando em a[0] for (int i=0;i<tamanho;i++) { cout << &quot;Entre com o valor da posicao &quot; << i << &quot;:&quot;; cin >> vet[i]; cout << endl; } for (int j=0;j<tamanho;j++) { cout << &quot;Posicao &quot; << j << &quot;:&quot; << vet[j]<<endl; } } Alocação Dinâmica

101. Classes e Objetos em C++ //file exvet1.h //header file para classe vetor const int inicio=0; class vetor{ private: int* v; //este e' o vetor int tamanho; //tamanho maximo do vetor, public: vetor (int tam); //construtor, aloca memória para o vetor. void atribui(int index,int valor); //altera uma posicao do vetor int conteudo(int index); //retorna conteudo de posicao do vetor int maximo(void); //retorna o maior elemento do vetor int primeiro(void); //primeiro indice do vetor int ultimo(void); //ultimo indice do vetor ~vetor() {delete v;} //inline function ou use delete v[]; }; TAD Vetor

102. Classes e Objetos em C++ //codigo, implementacao, para o header file #include <iostream.h> #include <stdlib.h> #include &quot;exvet1.h&quot; vetor::vetor (int tam) {v=new int[tam]; tamanho=tam;} void vetor::atribui(int index,int valor) { if (index<tamanho && index>=inicio) v[index]=valor; } int vetor::conteudo(int index) { if (index>=tamanho || index<inicio) { cerr << &quot;Fora dos limites&quot;; exit(1);} return v[index]; } int vetor::primeiro(void) { return inicio;} int vetor::ultimo(void) { return tamanho-1;} int vetor:: maximo(void) {int candidato=inicio; //candidato ao maximo for (int i=inicio;i<tamanho;i++) if (v[i]>v[candidato]) candidato=i; return v[candidato];}

103. Classes e Objetos em C++ //programa pricipal #include <iostream.h> #include &quot;exvet1.h&quot; main() { int aux; //para ler valor a atribuir vetor meu(5); for (int i=meu.primeiro();i<=meu.ultimo();i++) { cout << &quot;Entre com valor da posicao:&quot; << i << &quot;&quot;; cin >> aux; meu.atribui(i,aux); } for (int j=meu.primeiro();j<=meu.ultimo();j++) cout<< meu.conteudo(j)<< &quot; &quot;; cout <<endl << &quot;Maximo:&quot; << meu.maximo(); return 0; }

117. Projeto de Programas OO Classe A Classe B Classe A Classe B ou unidirecional bidirecional Classe A Classe B bidirecional ou não determinada

118. Projeto de Programas OO Para facilitar seu entendimento, uma associação precisa ser nomeada - O nome é representado como um “rótulo” colocado ao longo da linha de associação - Um nome de associação é usualmente um verbo ou uma frase verbal Aluno Dsiciplina Cursa

119. Projeto de Programas OO Aluno Disciplina cursa tem matriculado Aluno Disciplina Cursa   Tem matriculado

121. Projeto de Programas OO Muitos * Exatamente um 1 Zero ou mais 0.. * Um ou mais 1.. * Zero ou um 0..1 Faixa especificada 2..4 Pessoa Disciplina Aluno 1..* 1.. *

123. Projeto de Programas OO class TCliente { protected: int nClientCod; char* pcNome; char* pcEndereco; int* nProdCod; //array de inteiros com todos os produtos que possui public: ... } class TProduto { protected: int nProdCod; char* pcDescri; public: ... } Uma instância de Cliente sabe todos os Produtos que possui

124. Projeto de Programas OO class TCliente { protected: int nClientCod; char* pcNome; char* pcEndereco; public: ... } class TProduto { protected: int nProdCod; char* pcDescri; int nClientCod; //qual cliente o possui public: ... } Uma instância de Produto sabe qual o Cliente a possui

126. Projeto de Programas OO class TAluno { protected: char* pcDRE; char** pacMatricula; //matriculas dos professores que possui char* pcNome; int nIdade; public: ... } class TProfessor { protected: char* pcMatricula; char*pcNome; char** pacDRE; //array de strings com DRE dos alunos que possui public: ... }

127. Projeto de Programas OO

130. Projeto de Programas OO Todo Parte1 Parte2

131. Projeto de Programas OO Turma Aluno 1..* *

133. Projeto de Programas OO Departamento * Disciplina

135. Projeto de Programas OO Curso 1..* 0.. * Disciplina Aluno 3..10 Curso e disciplina são altamente acoplados (1 curso é formado por 1 ou mais disciplinas) Objetos independentes

138. Projeto de Programas OO Atributos Nome do objeto Operações Unidades organizacionais Estrutura Lugar Entidades externas Papéis Eventos Coisas

153. Herança e Polimorfismo em C++ Herança Pública: Na herança pública as classes filhas passam a ter as mesmas funções membro public da classe pai, as classes filhas podem acrescentar funções membro, dados membro e até redefinir funções membro herdadas . Os atributos da classe pai não são acessíveis diretamente na classe filha a não ser que sejam qualificados como protected . Por isso é que se diz que as classes filhas garantem pelo menos o comportamento da classe pai, podendo acrescentar mais características.

155. Herança e Polimorfismo em C++ Construtores e herança: No construtor de uma classe filha o programador pode incluir a chamada do construtor da classe pai. Destrutores e herança: Quando um objeto da classe derivada é destruído, o destrutor da classe pai também é chamado dando a oportunidade de liberar a memória ocupada pelos atributos private da classe pai.

157. Herança e Polimorfismo em C++ Tipo de acesso original na Classe base Tipo de acesso resultante na classe derivada Tipo de herança Não acess. Private Private Private Não acess. Protected Public Public Private Protected Public

158. Herança e Polimorfismo em C++ Exemplo

159. Herança e Polimorfismo em C++ //header file class ponto { private: float x; float y; public. ponto(float a,float b); void inicializa(float a,float b); float retorna_x(void); float retorna_y(void); void altera_x(float a); void altera_y(float b); void mostra(void); }; class ponto_reflete:public ponto { private: //se voce quer adicionar atributos... public: ponto_reflete(float a, float b); void reflete(void); }; class ponto_move:public ponto { public: ponto_move(float a,float b); void move(float dx,float dy); };

160. Herança e Polimorfismo em C++ //implementation file #include <iostream.h> #include &quot;pontos.h&quot; ponto::ponto(float a,float b) { inicializa(a,b); } void ponto::inicializa(float a,float b) { x=a; y=b; } float ponto::retorna_x(void) { return x; } float ponto::retorna_y(void) { return y; } void ponto::altera_x(float a) { x=a; } void ponto::altera_y(float b) { y=b; } void ponto::mostra(void) { cout << &quot;(&quot; << x << &quot;,&quot; << y << &quot;)&quot; <<endl; }

161. Herança e Polimorfismo em C++ ponto_reflete::ponto_reflete(float a,float b):ponto(a,b) { } void ponto_reflete::reflete(void) { altera_x(-retorna_x()); altera_y(-retorna_y()); } ponto_move::ponto_move(float a,float b):ponto(a,b) { } void ponto_move::move(float dx,float dy) { altera_x(retorna_x()+dx); altera_y(retorna_y()+dy); }

162. Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;pontos.h&quot; void main() { ponto_reflete p1(3.14,2.17); p1.reflete(); cout << &quot;P1&quot;; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << &quot;P2&quot;; p2.mostra(); } Resultado do programa: P1(-3.14,-2.17) P2(1.5,1.5)

163. Herança e Polimorfismo em C++ Herança Private: class herdeira: private nome_classe_base; As funções membro desta classe base só são acessíveis dentro das declarações da classe filha, ou seja a classe filha não atende por essas funções membro, mas pode usá-las em seu código. Normalmente, quando se usa herança dizemos que a classe filha garante no mínimo o comportamento da classe pai (em termos de funções membro) , a herança private pode invalidar esta premissa.

164. Herança e Polimorfismo em C++ protected deixa os atributos da classe pai visíveis, acessíveis “hierarquia abaixo”. O uso de protected serve como um nível intermediário de proteção entre o acesso public e o private. Membros protected da classe podem ser acessados por membros friends Da classe base e por membros friend das classes derivadas; Nenhuma outra função pode acessar membros protected de uma Classe base.

166. Herança e Polimorfismo em C++ ponto_reflete redefine a função membro mostra da classe pai, enquanto que a classe herdeira ponto_move aceita a definição da função membro mostra dada pela classe ponto que é sua classe pai.

167. Herança e Polimorfismo em C++ //header file class ponto { private: float x; //sao ocultos por default float y; //sao ocultos por default public: //daqui em diante tudo e acessivel. ponto(float a,float b); void inicializa(float a,float b); float retorna_x(void); float retorna_y(void); void altera_x(float a); void altera_y(float b); void mostra(void); }; class ponto_reflete:public ponto { private: //se voce quer adicionar dados membro public: ponto_reflete(float a, float b); void reflete(void); void mostra(void); //redefinicao }; class ponto_move:public ponto { public: ponto_move(float a,float b); void move(float dx,float dy); //esta classe filha nao redefine mostra };

168. Herança e Polimorfismo em C++ //implementation file #include <iostream.h> #include &quot;pontos.h&quot; ponto::ponto(float a,float b){ inicializa(a,b); } void ponto::inicializa(float a,float b){ x=a; y=b; } float ponto::retorna_x(void) { return x; } float ponto::retorna_y(void) { return y; } void ponto::altera_x(float a) { x=a; } void ponto::altera_y(float b) { y=b; } void ponto::mostra(void){ cout << &quot;(&quot; << x << &quot;,&quot; << y << &quot;)&quot; <<endl; } ponto_reflete::ponto_reflete(float a,float b):ponto(a,b) { } void ponto_reflete::reflete(void){ altera_x(-retorna_x()); altera_y(-retorna_y()); } void ponto_reflete::mostra(void) { cout << &quot;X:&quot; << retorna_x() << &quot; Y:&quot;; cout << retorna_y() << endl; } //somente altera o formato de impressao ponto_move::ponto_move(float a,float b):ponto(a,b) { } void ponto_move::move(float dx,float dy) { altera_x(retorna_x()+dx); altera_y(retorna_y()+dy); }

169. Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;pontos.h&quot; void main() { ponto_reflete p1(3.14,2.17); p1.reflete(); cout << &quot;P1&quot;; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << &quot;P2&quot;; p2.mostra(); } Resultado do programa: P1X:-3.14 Y:-2.17 P2(1.5,1.5)

171. Herança e Polimorfismo em C++

177. Herança e Polimorfismo em C++ #include<iostream.h> class Base{ public: virtual void vfunc(){ cout<<“esta e vfunc() da base ”; } }; class Derivada1:public base{ public: void vfunc(){ cout<<“esta e vfunc() da derivada1 ”; } }; class Derivada2:public base{ public: void vfunc(){ cout <<“esta e vfunc() da derivada2 ”; } };

178. Herança e Polimorfismo em C++ main(){ Base *p, b; Derivada1 d1; Derivada2 d2; p = &b; p->vfunc(); p = &d1; p->vfunc(); p = &d2; p->vfunc(); Return 0; }

184. Herança e Polimorfismo em C++ //header file funcover.h float abs(float a); int abs(int a); //implementation file #include &quot;funcover.h&quot; float abs(float a) { if (a>0.0) return a; else return -a; } int abs(int a) { if (a>0) return a; else return -a; } #include <iostream.h> #include &quot;funcover.h&quot; void main(){ int i1; float f1; cout << abs(int(-10))<<endl; cout << abs(float(-10.1))<<endl; f1=-9.1; i1=8.0; cout << abs(f1) << endl; cout << abs(i1) << endl; }

186. Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;funcover.h&quot; void main() { cout << max(float(1.2),float(3.4),float(2.1))<<endl; cout << max(float(1.5),float(.65)) << endl; cout << max(int(12),int(120)); }

188. Herança e Polimorfismo em C++ vetor::vetor (int tam) {v=new float[tam]; tamanho=tam;} int vetor::primeiro (void) {return inicio;} int vetor::ultimo (void) {return tamanho-1;} float& vetor::operator[](int i){ if (i<0 || i>=tamanho) {cout << &quot;Fora dos limites! Exit program&quot;; exit(1);} return v[i]; } float vetor:: maximo(void) {int candidato=inicio; for (int i=inicio;i<tamanho;i++) if (v[i]>v[candidato]) candidato=i; return v[candidato];}

203. Herança e Polimorfismo em C++ //exvetit6 , arquivo com definicoes do iterador. class iterador{ //classe base abstrata public: int comeca(void) {cout << &quot;Erro, classe abstrata!&quot;;} float operator()() {cout << &quot;Erro, classe abstrata!&quot;; return 0;} int operator!(void) {return 0;} int operator ++() {return 0;} void operator=(float entra) {;} }; class iteradorvetor:public iterador { private: vetor vetorref; int posicao; //classe filha acrescentando dados membro public: iteradorvetor(vetor & v); int comeca(); int operator!(); int operator ++ (); float operator() (); void operator= (float entra); int pos();

209. Herança e Polimorfismo em C++ #include <iostream.h> class relogio { friend class caixa_de_mensagem; //permitiu acesso as definicoes private e public private: int hora; int minuto; int segundo; //atributos private, encapsulados public: relogio(int h,int m,int s) {hora=h; minuto=m; segundo=s;} } ;

210. Herança e Polimorfismo em C++ class caixa_de_mensagem{ public: void imprime(relogio a){ cout << a.hora << &quot;:&quot; << a.minuto << &quot;:&quot; << a.segundo << endl; } } ; void main(){ relogio meurolex(11,30,10); caixa_de_mensagem ativa; ativa.imprime(meurolex); }

228. Herança e Polimorfismo em C++ template < class T > class Vector { T * data; int size; public : Vector( int ); ~ Vector() { delete [] data; } T& operator [] ( int i) { return data[i]; } }; // observe a sintaxe para definicao fora da classe template < class T > Vector < T > ::Vector( int n) { data = new T[n]; size = n;

229. Herança e Polimorfismo em C++ // exemplo de declaracao main () { Vector <int> ix(5); // gera um vetor de inteiros Vector <float> fx(6); // gera vetor de floats //... }

252. Programa