programação orientada a objetos · programação orientada a objetos aula xii prof. felício...
TRANSCRIPT
Programação Orientada a Objetos
Aula XII
Prof. Felício Bruzzi Barros
Junho de 2008
Templates - funções
void Troca(int &m, int &n){
int aux;aux = m;m = n;n = aux;
}
Templates - funções
void Troca(char &m, char &n){
char aux;aux = m;m = n;n = aux;
}
Templates - funções
Reescrever o código (no caso a função Troca) para cada tipo que se deseja utilizar implica em: – consumo de tempo do programador;– desperdício de espaço no código;– desperdício de memória pois toda função
sobrecarregada irá implicar em em tê-la compilada, mesmo que não seja usada.
Templates - funções
void Troca(tipo_var &m, tipo_var &n){
tipo_var aux;aux = m;m = n;n = aux;
}
exemplo:troca
Templates - funções
template <class T> T func (T parâmetro, …){…}
Define-se uma função padrão ou modelo.
T é um parâmetro (poderia ser qualquer outra letra), quepode ser substituído por qualquer tipo.
T é também conhecido como argumento do modelo(template)
Templates - funções
template <class T> T func (T parâmetro, …){…}
Argumento do template.
(Sempre um ou mais)
Pode estar presente na lista de argumentos da função e/ouno código da mesma
Templates - funções
template <class T> T func (T parâmetro, …){…}
Palavrareservada, podeser substituídapor typename
Templates - funções
template <class T> T func (T parâmetro, …){…}
Palavra reservada quemostra ao compilador
que o código seguinte éum modelo
Templates - funções
As funções templates, como são apenas modelos ou padrões, não podem ser separadas entre um arquivo cabeçalho com a declaração e um arquivo cpp (a ser compilado com sua definição).Definição e declaração devem ficar juntos.
Templates - funções
// file.h
template <class T> void Troca(T &m, T &n)
{T aux;aux = m;m = n;n = aux;
}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
int var1, var2;var1=5;var2=10;cout << "originalmente var1 = " << var1 << " e var2 = " << var2 << endl;Troca(var1,var2);cout << "posteriormente var1 = " << var1 << " e var2 = " << var2 << endl;return 0;
}
Templates - funções
// file.h
template <class T> void Troca(T &, T &)
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
int var1, var2;var1=5;var2=10;cout << "originalmente var1 = " << var1 << " e var2 = " << var2 << endl;Troca(var1,var2);cout << "posteriormente var1 = " << var1 << " e var2 = " << var2 << endl;return 0;
}
// file.cpp
export template <class ax> void Troca(T &m, T &n)
{T aux;aux = m;m = n;n = aux;
}
Significa acessível para outraunidade de compilação
Templates - funções
template <class T> T(ou tipo) f(T parâmetro){ … }
template <class T> T(ou tipo) f(T par1, T par2, …){ … }
template <class T> T(ou tipo) f(T par1, tipo par2, …){ … }
template <class T1, class T2, …) T1(ou T2, ou … tipo) f(T1 par1, T2 par2, tipo par3, …)
Templates - funções
// file.h
template <class T> T* f(T a){...}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
int i=5;double d=3.4;f(i);f(5);f(d);return 0;
}
Templates – funções / sobrecarga
// file.h
template <class C> C absmax(C a, C b){
return (abs(a) > abs(b)) ? a : b;}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
absmax(-1,2);absmax(2.7,5.6); absmax(5,6.9);return 0;
}
Templates – funções
// file.h
template <class C> C absmax(C a, C b){
return (abs(a) > abs(b)) ? a : b;}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
absmax(-1,2); // absmax<int>(1,2)absmax(2.7,5.6); // absmax<double>(2.7,5.6)absmax(5,6.9); // ambíguoabsmax<double>(5,6.9) // OKreturn 0;
}
Templates – funções (sobrecarga)
// file.h
template <class T> T abs(T a){
...
}
double abs(double a){
...
}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
abs(2.0);abs(2);return 0;
}
Templates – funções (sobrecarga)
// file.h
template <class T> T abs(T a){
...
}
double abs(double a){
...
}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
abs(2.0); // abs(double 2.0)abs(2); // abs<int>(int 2)return 0;
}
Templates - funções
// file.h
template <class T, class S> T g(S a){...}
// main.cpp#include "file.h"#include <iostream>using namespace std;
int main(){
int i=5;double d=3.4;g<int, double>(d); // T=int, S=doubleg<double>(i); // T=double, S=intg(d); // T=?, S=doublereturn 0;
}
Templates - classes
São modelos que permitem definir classes genéricas para manipular diferentes tipos de dados.Um caso típico são as classes contêineres (que contêm objetos de um tipo de dado genérico).São denominadas classes parametrizáveis.
Templates - classes
template <class T> class Nome_da_classe{…};
Templates - classes
push()
push()push()
pop()
pop()pop()
exemplo:pilha1
Templates - classes
template <class T> class Pilha{private:
T dados[50];int num;int topo;
public:Pilha(): num(50), topo(0) {};void push(T elem){
if (topo<=num)dados[topo++]=elem;
return;};T pop(){
if (topo>0)return dados[--topo];
exit(1);};int get_num() {return num;};
};
Dentro do escopo de Pilha<T>, é
redundante qualificaras funções membros
com <T>.
Templates - classes
template <class T, int n_max=50> class Pilha{private:
T dados[n_max];int num;int topo;
public:Pilha(): num(n_max), topo(0)
{};void push(T elem){
if (topo<=num)dados[topo++]=elem;
return;};T pop(){
if (topo>0)return dados[--topo];
exit(1);};int get_num() {return num;};
};
#include "pilha.h"
int main(){
Pilha<double> p;p.push(5.0);p.push(4.5);p.push(10.2);p.push(20.3);cout << p.pop() << endl;cout << p.pop() << endl;cout << p.pop() << endl;cout << p.pop() << endl;return 0;
}
Templates - classes
template <class T, int n_max=50> class Pilha{private:
T dados[n_max];int num;int topo;
public:Pilha(): num(n_max), topo(0)
{};void push(T elem){
if (topo<=num)dados[topo++]=elem;
return;};T pop(){
if (topo>0)return dados[--topo];
exit(1);};int get_num() {return num;};
};
#include "pilha.h"
int main(){
Pilha<double,10> p;p.push(5.0);p.push(4.5);p.push(10.2);p.push(20.3);cout << p.pop() << endl;cout << p.pop() << endl;cout << p.pop() << endl;cout << p.pop() << endl;return 0;
}
exemplo:pilha2
Templates - classes
template <class T1, class T2, tipo nome, …>class Nome_da_classe{…};
Templates
Templates são conhecidos como tipos parametrizados.Possibilitam um polimorfismo em tempo de compilação. Pois o compilador iráespecializar as formas (funções ou classes) de acordo com argumentos passados paraos templates.
Templates
Ao encontrar uma definição de template, o código não é gerado imediatamente.O compilador gera apenas instâncias específicas quando encontra uma chamada de template.Os compiladores precisam, portanto, ter acesso ao código fonte.Não ocorre perda de rendimento.Quanto maior o número de instâncias, maior o código.
Laboratório X1
Utilize o código VetMat, para generizá-lopor meio de templates.A classe matriz deverá agora ser capaz de trabalhar com tipos float, int, double, longdouble, etc.
Quarto trabalho (parte três)
Utilize o código de vetores e matrizes, para generizá-lo por meio de templates.As classes vetor e matriz deverão agora ser capaz de trabalhar com tipos float, int, double, long double, etc.
Data de entrega: juntamente com a prova.