Física Computacional 11 Classes

Transcrição

1 Física Computacional 11 Classes 1. Classes a. Overload de funções b. Parâmetros por omissão c. Overload de operadores d. Exemplos Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 1

2 Contrariamente ao C, podemos em C++ ter funções diferentes com o mesmo nome overload de funções A lista de parâmetros de cada função terá que ser distinta O tipo de retorno poderá ser diferente mas duas funções não poderão ser distinguidas apenas pelo pelo tipo de retorno int func(int); int func(int, int); //Ok. Distingue-se da primeira função double func(double,double); //Ok. Distingue-se da primeira e segunda float func(double,double); //ERRO: Parâmetros iguais à anterior isto é assim, porque em C++ podemos chamar uma função e ignorar o seu valor de retorno e assim não saberíamos que função estávamos a chamar Também podemos fazer overload dos métodos de uma classe Para além disto, poderemos ainda usar templates de funções (a falar mais adiante) Overload de funções Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 2

3 Uma forma muito prática de criar versões de uma mesma função é utilizar parâmetros por omissão: void f(int x = 0, int y = 0, int z = 0 ); // pode ser chamada de 4 maneiras diferentes f(); //chama f(0,0,0) f(1); //chama f(1,0,0) f(1,2); //chama f(1,2,0) f(1,2,3); //chama f(1,2,3) Isto também se pode aplicar aos métodos de uma classe, incluindo os construtores. Exemplo: struct Complex { double re, im; Complex( double x = 0, double y = 0) : re(x), im(y) { ; Complex z; //O mesmo que : Complex z(0,0); Complex w = 1; //O mesmo que w(1) == w(1,0) Parâmetros por omissão Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 3

4 É também possível redefinir os operadores usais do C/C++ para novos tipos overload de operadores, com algumas limitações, não é possível definir novos $.. `, etc, não se pode redefinir os operadores que atuam nos tipos básicos : por ex. utilizar o operador ^ (ou exclusivo bit a bit) para potenciação, é impossível alterar as relações de precedência entre os operadores. Podemos, por ex., sendo definida uma classe para números complexos, redefinir os operadores usais + - * / += -= *= /= para operações com números complexos Nem todos os operadores podem ser redefinidos:?:(operador ternário) ::. sizeof typeid Desaconselhamos o overload de alguns operadores: &&, Deve evitar-se usar num contexto em que não seja óbvio o seu significado. Overload de operadores Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 4

5 Usa-se a keyword operator para definir novos operadores Exemplo (usando uma classe Complex definida anteriormente para complexos, com uma parte real e uma parte imaginária): Complex operator+(const Complex& a, const Complex& b) {// const não altera argumento return Complex(a.re+b.re, a.im+b.im); // & permite passar por referencia, // sem copiar ou seja passando // menos memoria Complex operator*(const Complex& a, const Complex& b) { return Complex(a.re*b.re-a.im*b.im,a.re*b.im+a.im*b.re); Complex operator+=(complex& a, const Complex& b) { a.re += b.re; a.im += b.im; return a; Overload de operadores Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 5

6 Podemos redefinir os operadores como funções externas à classe (eventualmente friend) ou como métodos da classe No primeiro caso temos uma função externa pois é declarada friend. No segundo caso, a instância da classe corresponde ao primeiro argumento # include <iostream> class A { int x; # include <iostream> class A { int x; public: A(int _x = 0) : x(_x) { friend bool operator<(const A& a, const A& b) { return a.x<b.x; //Função externa ; int main{ A a=4, b(3); std::cout << (a < b) << std::endl; // imprime false, ou seja 0 Overload de operadores public: A(int _x = 0) : x(_x) { bool operator<(const A& b) const { return x < b.x; //Método ; int main{ A a=2,b(3); std::cout << (a < b) << std::endl; // imprime true, ou seja 1 Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 6

7 Overload do operador= Mais uma vez: não confundir o operador = com o construtor por cópia: #include <iostream> struct S { S() { // construtor por defeito S(const S&) { // construtor por cópia std::cout << "Construtor por cópia" << std::endl; const S& operator=(const S&) { // overload do operador = std::cout << "Operador =" << std::endl; return *this; ; int main() { S a; S b = a; //escreve Construtor por cópia a = b; //escreve Operador = Overload de operadores operador = Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 7

8 Exemplo (classe Vector): //A expressão a = b; deverá copiar os elementos de b para a const Vector& operator=(const Vector& vec) { if (this == &vec) return *this; //se é o mesmo vector não faz nada delete[] data; //senão, apaga memória antiga len = vec.len; //e cria novo vector data = new data[len]; // e copia memória: for(size_t i = 0; i < len; ++i) data[i] = vec.data[i]; return *this; //e retorna o próprio para permitir expressões encadeadas: a = b = c; Note-se a linha if (this == &vec) return *this;. Esta impede que, caso façamos a = a, (que pode ocorrer através de um ponteiro ou referência) apaguemos o conteúdo de data e depois acedamos a ela através de vec.data Overload de operadores operador = Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 8

9 Os operadores de conversão para um tipo X utilizam a sintaxe operator X() sem especificar o tipo de retorno (que será X). Exemplo: class MyInt { int x; ; public: MyInt(int _x) : x(_x) { // construtor standard operator int() const { return x; operator unsigned() const { return unsigned(x); int main() { MyInt a = 4; // chama o construtor int i = a; unsigned u = a; Overload de operadores operadores de conversão Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 9

10 Em C++11 o uso destes operadores pode se forçar a ter de ser explícito usando a keyword explicit: class MyInt { int x; ; public: MyInt(int _x) : x(_x) { operator int() const { return x; explicit operator unsigned() const { return unsigned(x); int main() { MyInt a = 4; int i = a; //OK. Conversão é implícita //unsigned u = a; //daria ERRO: conversão terá de ser explícita unsigned u = (unsigned)a; //OK. Uso explícito do operador de cast Overload de operadores operadores de conversão Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 10

11 Podemos fazer com que uma classe se comporte como um vetor através do overload do operador [], ou [ ] Por exemplo, na nossa classe Vector definida na aula anterior, poderíamos substituir os métodos get e set por duas versões do operador [] : //versão constante, retorna valor double Vector::operator[](size_t i) const { return ptr[i]; //versão não constante, retorna referência para mutável double& Vector::operator[](size_t i) { return ptr[i]; Podemos então escrever: Vector a(10); a[4] = 7; double b = a[4]; com o significado expectável b=7., Overload de operadores operador [] Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 11

12 O operador de chamada de função () também pode ser redefinido Este é o único operador que pode ser redefinido com um número arbitrário de argumentos Por vezes utiliza-se este operador em substituição do operador [] para arrays multidimensionais, uma vez que este último só pode ter um parâmetro e a sintaxe a[i][j][k] corresponderia a três chamadas a três operadores [] diferentes. Os objetos que redefinem este operador chamam-se functores Estes objetos tornam-se particularmente úteis em conjunto com templates, que permitem construir códigos que funcionam quer para as funções comuns quer para functores (a ver em aula futura). Overload de operadores operador () Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 12

13 1 /4 Ex: Função gaussiana normalizada a ( π ) e 1 2 a x2 #include <cmath> class Gaussian { //Função gaussiana normalizada N exp( -.5 * a * x * x ) double a, N; public: explicit Gaussian(double _a) : a(_a) { N = std::pow( a / M_PI,.25 ); //Só precisa calcular N uma vez double operator()(double x) const { return N * std::exp( -.5 * a * x * x ); ; int main() { Gaussian f(5); //cria gaussiana com parâmetro a == 5 // nota, não usar nome de uma função existente double y = f(4); //Retorna o valor da função para x == 4 Overload de operadores operador () Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 13

14 Podemos redefinir os operadores de input e output << e >> (que já de si são redefinições dos operatores de shift para inteiros) para novos tipos, facilitando a escrita e leitura destes tipos para/de ficheiros Os objectos de escrita são os std::ostream e os de leitura os std::istream Exemplo (voltando a usar a classe Complex por nós definida): #include <iostream> //output std::ostream& operator<<(std::ostream& out, const Complex& z) { out << z.re << << z.im; return out; //input std::istream& operator>>(std::istream& in, Complex& z) { in >> z.re >> z.im; return in; Overload de operadores input e output Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 14

15 A stream é retornada pelos operadores por modo a permitir a habitual sintaxe encadeada: std::cin >> a >> b >> c; Utilização: #include <fstream> //Leitura e escrita para ficheiros int main() { using namespace std; Complex z(1,2), w; cin >> w; ofstream output( out.txt ); output << z << << w << << z+1.0 << endl; Overload de operadores input e output Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 15

16 Para concluir, os alunos devem estudar o código presente na página da cadeira, overloadefriends.cpp Overload de operadores input e output Física Computacional - MEFT 2013/14 P. Bicudo & M. Cardoso 16