Linguagem de Programação

Plano de Aula
● Polimorfismo
● Sobrecarga de Funções (Métodos);
● Herança;

2
 POLIMORFISMO:

● Polimorfismo – Poli -> varias; Morfos -> formas;

●
Significa que um objeto pode assumir diferentes
formas;
● O conceito de polimorfismo está associado a
Herança;
● É caracterizado como o fato de uma operação
poder ser implementada de diferentes maneiras
pelas classes na hierarquia.

3
POLIMORFISMO:

4
 POLIMORFISMO:
● Polimorfismo é uma característica na qual os mesmos
atributos ou métodos podem ser utilizados por objetos
distintos e com implementações de lógica diferentes.
Por exemplo, podemos dizer que um carro e uma bicicleta
são veículos utilizados para locomoção e ambos contêm
um método “Andar” em comum, porém, a implementação de
cada um deles é feita de forma diferente.
Exemplo:
int x1,x2,x3; // variáveis globais a inicializar
void inicializa() { // chamada sem parâmetros
x1=x2=x3=0; // preenche variáveis com zeros
}
void inicializa(int value) {// chamada com parâmetro
x1=x2=x3=value; // preenche variáveis com
parâmetro passado
}

5
 POLIMORFISMO:

● Neste caso, a função inicializa pode ter dois

códigos diferentes. O compilador determina em
tempo de compilação qual é a que será usada pelo
prototype. Por exemplo:
inicializa(); // chama a função de cima
inicializa(3); // chama a função de baixo

6
 Exemplo - POLIMORFISMO:
#include<iostream>
#include <string>
using namespace std;
int main()
class carro{ carro() {
private: {
int velmax; velmax=120; carro c1;
string nome; potencia=100;
public: nome="popular"; cout<<c1.getnome()<<" -
int potencia; } "<<c1.getvelmax()<<" - "<<
int getvelmax(){ carro(int pt, string no){ c1.potencia<<endl;
return velmax; potencia=pt;
} nome=no; carro c2(200,"luxo");
string getnome(){ if(potencia<100) { cout<<c2.getnome()<<" -
return nome; velmax=120; "<<c2.getvelmax()<<" - "<<
} } else if(potencia<200){ c2.potencia<<endl;
velmax=240;
} else {velmax=360;
}
system("pause");
} return 0;
};
}
7
 SOBRECARGA DE FUNÇÕES
Uma maneira do C++ obter polimorfismo é pelo uso de sobrecarga de
funções. Em C++ duas ou mais funções podem compartilhar o mesmo
nome, contanto que as suas declarações de parâmetros sejam
diferentes. Nessa situação, as funções que compartilham o mesmo
nome são conhecidas como sobrecarregadas e o processo é chamado
de sobrecarga de funções. Por exemplo, considere este programa:

#include <iostream>
using namespace std;
//a função quadrado é sobrecarregada duas vezes
int quadrado(int i)
int quadrado (int i); {
double quadrado (double d); cout << "Dentro da funcao quadrado() que usa ";
cout << "um argumento inteiro.\n";
int main(){ return (i * i);
cout << quadrado(10) << "\n"; }
cout << quadrado(11.0) << "\n"; double quadrado(double d)
system("pause"); {
return(0); cout << "Dentro da funcao quadrado() que usa ";
} cout << "um argumento double.\n";
return (d * d);
}
8
 SOBRECARGA DE FUNÇÕES
● O programa anterior cria duas funções similares, porém diferentes,
chamadas de quadrado( ). Cada uma delas retorna o quadrado do seu
argumento. Como o programa ilustra, o compilador sabe qual função
usar em cada situação por causa do tipo de argumento.
● O mérito da sobrecarga de funções é permitir que conjuntos
relacionados de funções sejam acessados usando-se somente um
nome. Nesse sentido, a sobrecarga de função deixa que se crie um
nome genérico para algumas operações, com o compilador resolvendo
exatamente qual função é necessária no momento para realizar a
operação.
● O que torna a sobrecarga de funções importante é o fato de ela poder
ajudar no tratamento de complexidades. Para entender como, considere
este exemplo. Muitos compiladores de linguagem C contêm funções
como atoi( ), atof( ) e atol( ) nas suas bibliotecas-padrões. Coletivamente,
essas funções convertem uma string de dígitos em formatos internos de
inteiros, double e long, respectivamente. Embora essas funções
realizem ações quase idênticas, três nomes completamente diferentes
devem ser usados em C para representar essas tarefas, o que torna a
situação mais complexa do que é na realidade.
9
 Exercício - SOBRECARGA DE FUNÇÕES
● Implemente um código com sobrecarga de função em que seja feita
uma soma com valores declarados na própria função e outra função
soma com passagem de parâmetros inseridas no escopo do main.

1
0
 Exercício - SOBRECARGA DE FUNÇÕES
#include <iostream>

using namespace std;

void soma(int n1, int n2);

void soma ();

int main() void soma (int n1, int n2)

{ {
soma(20,30); int re;
soma(); re=n1+n2;
system("pause"); cout<<"\n Soma de "<<n1<<" com "<<n2<<" = "<<re<<"\n";
return 0; }
}
void soma()
{
int n1,n2,re;
n1=10;
n2=20;
re=n1+n2;
cout<<"\n Soma de "<<n1<<" com "<<n2<<" = "<<re<<"\n";
} 1
1
 HERANÇA
● Herança é o mecanismo para expressar a
similaridade entre Classes, simplificando a
definição de classes iguais que já foram definidas.
● O que um leão, um tigre, um gato, um lobo e um
dálmatas têm em comum?
● Como eles são relacionados?

1
2
HERANÇA

1
3
 HERANÇA
● Como definido, a herança é uma das principais características de uma
linguagem de programação orientada a objetos. Em C++, a herança é
suportada por permitir a uma class incorporar outra class na sua
declaração.
class veiculos_na_estrada{
int rodas;
int passageiros;
public:
void fixa_rodas(int num);
int obtem_rodas(void);
void fixa_passageiros(int num);
int obtem_passageiros(void);
};

1
4
 HERANÇA
● Essa rude definição de uma estrada de rodagem pode ser usada para
ajudar a determinar objetos específicos. Por exemplo, este código
declara uma class chamada caminhão usando veiculos_na_estrada:
class caminhao : public veiculos_na_estrada
{
int carga;
public:
void fixa_carga(int tamanho);
int obtem_carga(void);
void exibe(void);
};

1
5
 HERANÇA
● Note como veiculos_na_estrada é herdada. A forma geral para herança
é mostrada aqui:
class nome_da_nova_classe : acesso classe_herdada{...
● Aqui, acesso é opcional. Contudo, se estiver presente, ele deve ser
public, private ou protected. A utilização de public significa que todos
os elementos public do antepassado também serão public para a class
que os herda.
● Portanto, os membros da class caminhao têm acesso às funções
membros de veiculos_na_estrada, exatamente como se tivessem sido
declarados dentro da class caminhao. Entretanto, as funções
membros não têm acesso às partes privadas da class
veiculos_na_estrada.

16
 HERANÇA - exemplo

#include <iostream>
using namespace std;

class veiculos{
int rodas;
int passageiros;
public:
void fixa_rodas(int num);
int obtem_rodas(void);
void fixa_passageiros(int num);
int obtem_passageiros(void);
};

class caminhao: publicveiculos{

int carga;
public:
void fixa_carga(int tamanho);
int obtem_carga(void);
void exibe(void);
};
11
enum tipo {carro, furgao, perua};
class automovel: public veiculos{
enum tipo tipo_de_carro;
public:
void fixa_tipo(enum tipo t);
enum tipo obtem_tipo(void);
void exibe(void);
};
void veiculos::fixa_rodas(int num)
{
rodas = num;
}
int veiculos::obtem_rodas(void)
{
return (rodas);
}
void veiculos::fixa_passageiros(int num)
{
passageiros = num;
}
int veiculos::obtem_passageiros(void)
{
return (passageiros);
11
}
void caminhao::fixa_carga(int num)
{
carga = num;
}
int caminhao::obtem_carga(void)
{
return (carga);
}
void caminhao::exibe(void)
{
cout << "rodas: " << obtem_rodas() << "\n";
cout << "passageiros: " << obtem_passageiros() << "\n";
cout << "capacidade de carga em metros cubicos: " <<obtem_carga()<< "\n";
}

19
void automovel::fixa_tipo(enum tipo t)
{
tipo_de_carro = t;
}
enum tipo automovel::obtem_tipo(void)
{
return (tipo_de_carro);
}
void automovel::exibe(void)
{
cout << "rodas: " << obtem_rodas() << "\n";
cout << "passageiros: " << obtem_passageiros() << "\n";
cout << "tipo: ";
switch(obtem_tipo())
{
case furgao: cout << "furgao\n";
break;
case carro: cout << "carro\n";
break;
case perua: cout << "perua\n";
break;
}
}
20
int main()
{
caminhao t1, t2;
automovel c;
t1.fixa_rodas(18);
t1.fixa_passageiros(2);
t1.fixa_carga(3200);
t2.fixa_rodas(6);
t2.fixa_passageiros(3);
t2.fixa_carga(1200);
t1.exibe();
t2.exibe();
c.fixa_rodas(4);
c.fixa_passageiros(6);
c.fixa_tipo(furgao);
c.exibe();
system("pause");
return 0;
}

21
 Exercício - HERANÇA

• Crie a classe "motocicleta", derivada de "veiculos".

• Crie também uma classe chamada "aviões", derivada de "veículos".

2
2
 Bibliografia:
● DEITEL, H. M.; DEITEL, P. J. C++:Como Programar. 3. Ed.
Porto Alegre (RS): Bookman, 2001. 1098p
● SOUZA, M. A. F., GOMES, M. M.,SOARES, M. V., CONCILIO,
R., Algoritmos e Lógica de Programação, Editora Cengage
Learning, São Paulo, 2008.
●
Sergio Barbosa Villas-Boas, C / C++ e Orientação a Objetos
em Ambiente Multiplataforma
●
Apostila LINGUAGEM C/C++ UNIPAN - Faculdade de Ciências
Aplicadas de Cascavel – FACIAP Curso de Ciência da
Computação, Cascavel - PR, 2004

23