Introdução ao C++

Prévia do material em texto

C++ 
Prof. Marco Túlio Valente 
Prof. César Francisco de Moura Couto 
Prof. Pedro Felipe 
 
2 
C++ 
§  Criada por Bjarne Stroustrup 
§  AT&T Bell Labs, a partir de 1979 
§  Objetivo: introduzir conceitos de OO em C 
§  Inicialmente, chamava-se “C com Classes” 
§  Principais conceitos de OO 
§  Classes, inclusive genéricas e abstratas 
§  Herança (simples e múltipla)‏ 
§  Polimorfismo 
§  Chamada dinâmica de métodos 
3 
Exemplo de Classe 
class Cubo { 
private: // membros privados 
 int altura, largura, prof; // atributos 
public: // membros públicos 
 Cubo (int, int, int); // função construtora 
 int volume (); // métodos 
}; 
 
Cubo::Cubo (int a, int l, int p) // Construtora 
{ altura= a; largura:= l; prof:= p } 
 
int Cubo::volume () { return altura * largura * prof; } 
 
4 
Exemplo de Classe 
main () { 
 Cubo cb (7,8,9); // declara objeto e chama construtora 
 cout << cb.volume(); 
} 
 
§  Controle de visibilidade: membros de uma classe podem 
ser 
§  public: podem ser usados em qualquer ponto do 
programa 
§  private: podem ser usados apenas em métodos da 
própria classe (visibilidade default)‏ 
§  protected: podem ser usados apenas em métodos da 
classe e de suas subclasses 
 
5 
Funções Construtora e Destruidora 
§  Função construtora: 
§  Mesmo nome da classe 
§  Chamada automaticamente na declaração de objetos 
da classe 
§  Utilizada para inicializar atributos da classe 
§  Função destruidora: 
§  Nome da classe, prefixado por ~ 
§  Chamada implicitamente quando termina o escopo de 
um objeto da classe 
§  Usada para liberar memória alocada no heap, fechar 
arquivo, fechar conexão de rede etc 
6 
Herança 
§  Mecanismo para construir novas classes (chamadas de classes 
derivadas ou subclasses) a partir de classes já existentes 
(chamadas de classes base ou superclasses)‏ 
§  Objetivo: reutilização de código (subclasse herda atributos e 
métodos da superclasse)‏ 
 
class Hora { 
 int hora, min, seg; 
public: 
 Hora (int h, int m, int s) // construtora 
 { hora= h; min= m; seg= s; } 
 void imprime () 
 { cout << hora << “:” << min << “:” << seg; } 
}; 
7 
Exemplo de Herança 
class HoraCompleta: public Hora { 
protected: 
 char *fuso; // Fuso horário: “FNO”, “BRA”, “AMZ” ou “ACR” 
public: 
 HoraCompleta (int h, int m, int s, char *fs): Hora (h, m, s) { 
 fuso= fs; 
 } 
 void imprime () { 
 Hora::imprime (); // chama imprime da superclasse 
 cout << “ “ << fuso; 
 } 
}; 
8 
Herança Múltipla 
§  Exemplo: 
class aviao { ..... } 
class barco { .... } 
class hidroaviao: public aviao, public barco 
 { .... } 
§  A subclasse hidroaviao herda todos os atributos e métodos 
de aviao e de barco. 
9 
Colisão de Nomes 
class A { class B { 
 public: void f () { .... } public: void f () { .... } 
}; }; 
 
class C: public A, public B { 
public: 
 void g () { 
 f(); // Erro ! Ambíguo, qual f ? 
 A::f (); // OK, qualificação (operador ::) com o nome 
 B::f (); // da classe remove ambigüidade 
}; 
10 
Herança Repetida 
class A { public: int x; .....}; 
class B1: public A {.... }; 
class B2: public A {.... }; 
class C: public B1, public B2 { 
public: 
 void g () { 
 x= 2; // Erro 
 B1::x= 3; // OK, cópias diferentes de x 
 B2::x= 4; // OK, cópias diferentes de x 
 } 
}; 
11 
Classe Base Virtual 
§  Classe base virtual: usada para evitar que uma superclasse 
seja herdada mais de uma vez 
 
class A { public: int x; .....}; 
class B1: public virtual A {.... }; // classe base virtual 
class B2: public virtual A {.... }; // classe base virtual 
class C: public B1, public B2 { 
public: 
 void g () { 
 x= 2; // OK 
 B1::x= 3; B2::x= 4; // OK, mesma cópia de x 
 } 
}; 
12 
Polimorfismo 
§  Um apontador para uma classe base pode apontar para um 
objeto de uma classe dela derivada 
§  Exemplo: 
 
HoraCompleta hc (15,25,18, “BRA”); 
Hora *ph; 
ph= &hc; // atribuição polimórfica 
 
§  Somente apontadores possuem tipo estático e dinâmico. 
§  Tipo Estático: tipo com que o apontador foi declarado. 
Exemplo: Hora 
§  Tipo Dinâmico: tipo para o qual o apontador se refere em 
tempo de execução. Exemplo: HoraCompleta 
§  Atribuições polimórficas alteram o tipo dinâmico de um 
apontador 
13 
Funções Virtuais 
§  Chamadas utilizando o tipo dinâmico de um apontador 
 
class Hora { .... 
 virtual void imprime () { .... } 
} 
 
class HoraCompleta: public Hora { .... 
 virtual void imprime () { .... } 
} 
 
 main () { 
 HoraCompleta hc (21, 42, 12, “BRA”); 
 Hora *ph= &hc; // atribuição polimórfica 
 ph->imprime (); // imprime: 21:42:12 BRA 
 } 
 
14 
Classes Abstratas 
§  Classes que possuem uma ou mais funções virtuais puras, 
isto é, funções que não possuem implementação 
§  Não se pode criar objetos de classes abstratas 
§  Exemplo: 
 
class Poligono { .... 
 virtual float perimetro() = 0; // função virtual pura 
} 
..... 
Poligono t; // Erro ! 
 
§  Utilização: 
§  Projeto OO 
§  Raiz de uma hieararquia de classes 
15 
Ponteiro this 
§  Toda classe possui um ponteiro de nome this, que, dentro 
de um método da classe, aponta para o objeto que está 
sendo manipulado por este método (objeto receptor). 
§  Útil quando se precisa passar o objeto receptor como 
parãmetro de um outro método 
16 
Exemplo de Uso do this 
 Pilha undo; 
 class Circulo: public Poligono { 
 int raio; ........ 
 void aumenta_tam (int dr); 
 .... 
 } 
 void Circulo::aumenta_tam (int dr) { 
 undo.empilha (*this); // salva circulo corrente na pilha de undo 
 raio= raio+dr; 
 ...... // redesenha circulo com novo tamanho 
 } 
 ................. 
 Circulo c (10); 
 c.aumenta_tam (15); 
17 
Membros Estáticos 
§  Atributo estático: atributo que pertence à classe, sendo 
compartilhado por todos os objetos da mesma. 
§  Exemplo: atributo para armazenar o número de objetos já 
criados de uma classe 
 
 class Circulo { 
 int raio; 
 static int total_circulos; // atributo estático 
public: 
 Circulo (int r); 
 void imprime(); 
}; 
 
18 
Membros Estáticos 
int Circulo::total_circulos= 0; // inicializa atributo estático 
 
Circulo::Circulo (int r) { raio= r; total_circulos++; } 
 
void Circulo::imprime () 
{ cout << "\nTotal circulos: " << total_circulos; } 
..... 
Circulo c1 (10)‏ 
Circulo c2 (27); 
c1.imprime(); 
c2.imprime(); 
19 
Métodos Estáticos 
§  Métodos Estáticos: podem ser chamados sobre a classe e 
não sobre um objeto da mesma 
§  Somente podem acessar atributos estáticos da classe 
§  Não possuem o ponteiro this 
 
 class Circulo { 
 int raio; 
 static int total_circulos; // atributo estático 
public: 
 Circulo (int r); 
 static void imprime(); // método estático 
}; 
20 
Métodos Estáticos 
int Circulo::total_circulos= 0; // inicializa atributo estático 
 
Circulo::Circulo (int r) { raio= r; total_circulos++; } 
 
void Circulo::imprime () // somente acessa atributos estáticos 
{ cout << "\nTotal circulos: " << total_circulos; } 
..... 
Circulo c1 (10)‏ 
Circulo c2 (27); 
.......... 
Circulo::imprime(); // chama método estático 
21 
Classes Genéricas 
§  Classes Genéricas: permitem parametrizar a 
implementação de classes 
§  Exemplo: pilha de inteiros 
 
class pilha { 
 int topo; int vetor [100]; 
 public: 
 pilha (); 
 void empilha (int x);int desempilha (); 
}; 
22 
Classes Genéricas 
pilha::pilha () { topo= 0; } 
void pilha::empilha (int x) { vetor [topo++]= x; } 
int pilha::desempilha () { return vetor [--topo]; } 
 
§  Mas e se pilha de float ? Ou de char ? 
§  Solução “braçal”: “copiar e colar” + “trocar” 
§  Classes Genéricas: parametrizar uma classe com um 
parâmetro de tipo 
§  “copiar e colar” + “trocar” a cargo do compilador 
§  Chamadas em C++ de templates. 
23 
Templates: Definição 
template <class T> class pilha_gen { 
 int topo; 
 T vetor [100]; 
 public: 
 pilha_gen (); 
 void empilha (T x); 
 T desempilha (); 
}; 
template <class T> pilha_gen<T>:: 
 pilha_gen () { topo= 0; } 
template <class T> void pilha_gen<T>:: 
 empilha (T x) { vetor [topo++]= x; } 
template <class T> T pilha_gen<T>:: 
 desempilha () { return vetor [--topo]; } 
 
24 
Templates: Instanciação 
void main () { 
 int i; float x; 
 pilha_gen<char> pchar; // pchar: pilha de char 
 pilha_gen<float> pfloat; // pfloat: pilha de float 
 for (i=0; i < 10; i++)‏ 
 pfloat.empilha (3.14 * i); 
 for (i=0; i < 10; i++) { 
 x= pfloat.desempilha (); 
 cout << x << “\n”; 
 } ...... 
 } 
25 
Templates: Comentários Finais 
§  Em C++, pode-se também parametrizar uma classe com 
parâmetros que não sejam tipos 
 
 template <class T, int tam> class pilha_gen { 
 int topo; T vetor [tam]; ...... 
 }