08-classe

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Classes 
Abstração 
• A forma abstração utilizada para criar Tipos 
Abstratos de Dados (TAD). 
 
• Linguagem C: 
– struct 
 
• Linguagem C++: 
– class 
typedef struct { 
 int x, y, z; 
} PONTO_R3; 
class PONTO_R3 { 
 int x, y, z; 
} ; 
Classe 
 
 
• Consegue reunir variáveis (atributos da 
classe) e funções (métodos da classe) para 
operarem os atributos. 
Método Construtor 
• Método ou função construtora. 
 
• Método especial que possui o mesmo nome 
da classe. 
 
• É sempre evocado quando é criado uma 
instância da classe (um objeto da classe). 
Método Construtor 
• Uma classe pode ter vários métodos 
construtores, obtendo assim várias interfaces 
para instanciar uma classe. 
 
• Não retornam nada. 
 
• Geralmente inicializam os atributos da classe 
com valores e/ou reservam memória dinâmica 
(heap). 
Método Destrutor 
• Método ou função destrutora. 
• Método especial que é evocado (chamado) 
sempre no final de vida da instância da classe 
(objeto da classe). 
• Possui o mesmo nome da classe precedido por 
um ~. 
• Não retorna nenhum valor. 
• Realiza a liberação de memória alocada de forma 
dinâmica no heap. 
Exemplo de uma Classe 
class Ponto { 
 private: 
 double x, y; 
 public: 
 Ponto(double x, double y) { 
 this->x = x; 
 this->y = y; 
 } 
 double Ret_x() { return x; } 
 double Ret_y() { return y; } 
}; 
Atributos da classe 
Métodos da classe 
Referência this 
• Toda instancia (objeto) criado tem uma 
referencia (ponteiro) this. 
• Pode-se referenciar atributos e métodos da 
classe. 
• Utilizado muitas vezes para distinguir as 
variáveis locais aos métodos que possuem o 
mesmo nome. 
Exemplo da Referência this 
class Ponto { 
 private: 
 double x, y; 
 public: 
 Ponto(double x, double y) { 
 this->x = x; 
 this->y = y; 
 } 
 double Ret_x() { return x; } 
 double Ret_y() { return y; } 
}; 
Tem-se as variáveis locais 
x e y que prevalecem 
para diferenciar o x e y da 
classe utiliza-se o this 
Mais de um Método Construtor 
class Ponto { 
 public: 
 double x, y; 
 public: 
 Ponto(double x, double y) { 
 this->x = x; 
 this->y = y; 
 } 
 Ponto(Ponto & P) { 
 x = P.Ret_x(); 
 y = P.Ret_y(); 
 } 
 double Ret_x() { return x; } 
 double Ret_y() { return y; } 
 void Mostrar(void (*f)(Ponto P)) { 
 Ponto P(x,y); 
 f(P); 
 } 
}; 
#include <stdio.h> 
#include "ponto.h“ 
 
void Mostrar(Ponto P) { 
 printf("\n(%.2lf,%.2lf)",P.Ret_x(),P.Ret_y()); 
} 
int main(int argc, char *argv[]) { 
 Ponto P(10,20); 
 Ponto P1(20,20); 
 P1.Mostrar(Mostrar); 
 Ponto P2(P1); 
 P2.Mostrar(Mostrar); 
 return 0; 
} 
 
class Vetor { 
 public: 
 int tam; 
 double *v; 
 public: 
 Vetor(int tamanho) { 
 tam = tamanho; 
 v = (double *) malloc(sizeof(double) * tam); 
 . . . . . . 
 . . . . . . 
 } 
 ~Vetor() { 
 free(v); 
 } 
}; 
#include “vetor.h” 
 
int main(int argc, char *argv[]) { 
 Vetor V(10); 
 . . . . . . 
 . . . . . . 
 . . . . . . 
} 
vetor.h 
principal-vetor.cpp 
class Vetor { 
 public: 
 int tam; 
 double *v; 
 public: 
 vetor(int tamanho) ; 
 double elemento(int i); 
 void elemento(double e, int i) ; 
 Mostrar(void (*f)(Vetor)); 
 . . . . . . 
 . . . . . . 
 ~vetor(); 
}; 
#include “vetor.h” 
int main(int argc, char *argv[]) { 
 Vetor V(10); 
 V.elemento(12,4); 
 double x = V.elemento(4); 
 . . . . . . 
} 
 
Vetor :: vetor(int tamanho) { 
 . . . . . . 
} 
double Vetor :: elemento(int i) { 
 return (v[i]); 
} 
void Vetor :: elemento(double e, int i) { 
 v[i] = e; 
} 
void Vetor :: Mostrar(void (*f)(Vetor)) { 
 . . . . . . 
} 
 Vetor :: ~vetor() { 
 . . . . . . 
}; 
vetor.h 
principal-vetor.cpp 
vetor.cpp