Your SlideShare is downloading. ×
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Sobrecarga operadores
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Sobrecarga operadores

254

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
254
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
1
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. C++ - Sobrecarga de Operadores Sobrecarregar um operador significa redefinir seu símbolo, de maneira que elese aplique também a tipos de dados definidos pelo usuário como classes e estruturas. A implementação de sobrecarga de operadores é definida por meio de funçõeschamadas operadoras , criadas como membro da classe ou como funções globais.Limitações : Respeitar a definição original do operador • Não é possível mudar o operador de unário para binário. • Não se pode inventar símbolos novos. • Não é possível modificar a precedência de operadores por meio de sobrecarga. • Operadores que não podem ser sobrecarregados: • . (operador ponto) • :: (operador de resolução de escopo) • ? : (operador ternário)Sobrecarga de Operadores Unários : Operador de incremento pré-fixadoclass ponto{ private : int x, y; public : ponto (int x1=0, int y1=0) {x=x1; y=y1;} // construtor ponto operator ++( ) // função operadora pré-fixada { ++x; ++y; return ponto(x, y); } void printpt( ) const // imprime ponto { cout << ‘(‘ << x << ‘,’ << y << ‘)’; }};void main( ){ ponto p1, p2(2,3), p3; // declara e inicializa cout << “n p1 = “ ; p1.printpt( ); // imprime cout << “n++p1 = “ ; (++p1).printpt( ); // incrementa e imprime p3 = ++p2; // incrementa e atribui cout << “n p3 = “ ; p3.printpt( ); // imprime }
  • 2. Observ.: ++p1 ; é equivalente a p1.operator++( );Sobrecarga do operador de incremento pós-fixado : Para distinguir entre asformas pré e pós-fixada, o compilador utiliza o número de argumentos da funçãooperadora. • sem parâmetro : pré-fixado operator ++ ( ) • com um parâmetro do tipo int : pós-fixadooperator ++ (int)ponto operator ++(int) // função operadora pós-fixada{ ++x; ++y; return ponto(x-1, y-1);}Sobrecarga de operadores binários : função operadora com um argumento. Ex.: sobrecarga do + aritméticoclass venda{ ... venda operator + (venda v) const; // função operadora ...}venda venda :: operator + (venda v) const // soma dois objetos{ int pec = npecas + v.pecas; float pre = preco + v.preco; return venda(pec, pre);} ...void main( ){ venda A(58, 12734.53), B(30, 6000.30), T; T = A + B; ... }Somando objetos da classe ponto : funções operadorasclass ponto{ ... ponto operator + (ponto p) const // soma dois objetos { return ponto(x+p.x, y+p.y); } ponto operator + (int n) const // soma um número a um objeto { return ponto(x+n, y+n); }}void main( ){ ...
  • 3. p3 = p1 + p2; p4 = p1 + 5; ... }Observ.: p4 = p1 + 5 ; é equivalente a p4 = p1.operator + (5);por isso não podemos escrever instruções p4 = 5 + p1;que seriam interpretadas como: p4 = 5. operator + (p1) // erradoOperadores para manipular strings : +=, +, <, ==, >enum Boolean { False, True};class string{ ... string operator +=(string s) const { string temp; if (strlen(str) + strlen(s.str) < MAX) { strcpy( temp.str, str); strcat(temp.str, s.str); } else cout << “ nMemória Esgotada!! “; return temp; } string operator +(string s) const // concatena { string temp; temp +=s.str; return temp; } Boolean operator < (string s) const { return (strcmp(str, s.str) < 0) ? True : False; } Boolean operator ==(string s) const { return (strcmp(str, s.str) == 0) ? True : False;} string getstr( ) { gets(str); return string(str); } ...}void main ( ){ string s[MAX]; for (int n=0; n<= 80; n++) { cout << “ nDigite nome ou <enter> para encerrar “; if (s[n].getstr( ) == “”) break;
  • 4. } cout << “ nLista Original”; for (int i=0; i<n ; i++) { cout << “ ns[ “ << i << “] = “; s[i].print( ); } ordena (s, n); cout << “ nLista Ordenada”; for (int i=0; i<n ; i++) { cout << “ ns[ “ << i << “] = “; s[i].print( ); }}void ordena (string s[ ], int n){ string temp; int j; for (int i=0; i<n ; i++) for ( j=i+1; j<n ; j++) if (s[i] > s[j]) { temp =s[i]; s[i] = s[j]; s[j] = temp }}Sobrecarga do operador [ ] : checagem de limites de matrizes#include <iostream.h>#include <iomanip.h>const MAX = 50;class matriz{ private : float n[MAX]; public : matriz( ); // construtor float& operator [ ] (int indice); // sobrecarga de [ ] float media( int i);};matriz :: matriz( ){ for( int i=0; i < MAX; i++) n[i] = 0.0; }float& matriz :: operator [ ] (int indice)
  • 5. { static float x = -1; if ( indice >= 0 && indice < MAX) return n[indice]; else { cout << "nFora de limite"; return x; }}float matriz :: media (int i){ float m= 0.0; for (int j=0; j<i; j++) m += n[j]; return m/float(i); }void main( ){ matriz notas; cout << setprecision(2); int i=0; do { cout << ""nDigite a nota do aluno " << (i+1) << " : "; cin >> notas [i]; } while (notas[i++] >= 0); cout << "nMedia das notas : " << notas.media(i); }Observ. : A função operator[ ] retorna uma referência a um elemento da matriz n.Dessa forma, a expressão notas[i] age como o próprio elemento da matriz privada,podendo ser usada em instruções como cin >> notas[i]; ou notas[i] = 6.7; A função operator[ ] cria uma variável static , pois não é possível retornarreferência a uma variável automática.Conversões entre tipos básicos : • implícita double dvar = A; • explícita (operdor molde) double dvar = double (A);Conversão de tipos com classes :• objetos a tipos básicos - sobrecarga do operador molde criando função conversora. Ex.: Conversão de um objeto string a tipo int ou float#include <stdlib.h>
  • 6. ...class string{ ... operator int( ) const // função conversora { return atoi(str); } operator double( ) const // função conversora { return atof(str); } ...};void main ( ){ string s1("1234"), s2("1234.56"); int i = s1; // conversão de string para int double d = s2; // conversão de string para double ...}• tipos básicos a objetos : sobrecarga do operador de atribuição = Ex.: conversão de um int a um objeto string.Class string{ ... void operator = (int n) // sobrecarga do operador de atribuição { itoa(n, str, 10); } ...};void main ( ){ string s; s = 5392; // conversão de inteiro para string ...}• objeto a objeto (classes diferentes ) - objA = objBDois métodos : • função-membro conversora da classe B • construtor membro da classe APrimeiro método : função conversoraClasses graus e radianos. Converter objetos da classe radianos em objetos da classegraus (grau = radiano). Função conversora na classe radianos.
  • 7. #include <iostream.h>#include <iomanip.h>#define PI 3.141592653class graus{ private : double g; public : graus (double x) { g=x; } graus ( ) { g = 0; } void print( ) { cout << setiosflags (ios :: fixed) << setiosflags (ios :: showpoint) << setprecision (2) << g << “ xf8n”; }};class radianos{ private: double rad; public : radianos (double r) { rad = r ; } radianos ( ) {rad = 0.0 ; } operator graus ( ) // função conversora de rad. para graus { return graus(180.0*rad/PI); } void print( ) { cout << setioflags (ios :: fixed) << setiosflags (ios :: showpoint) << setprecision (2) << rad << “ rad n”; }};void main( ){ graus gr; radianos rd(PI); gr = rd; // converte radianos para graus ...}Segundo método : função construtora (implementada na classe graus)
  • 8. class radianos{ ... public : double getrad ( ) {return rad; } ...};class graus{ ... graus (radianos rd) // construtor para conversão { g = (180.0 * rd.getrad( ) / PI; } ...};void main( ){ graus gr; radianos rd(PI); gr = rd; // converte radianos para graus ...} • conversões dos dois lados : (graus em radianos e radianos em graus)As duas funções presentes na mesma classe.class radianos{ ...};class graus{ ... public : graus (radianos rd) // construtor para conversão { g = (180.0 * rd.getrad( ) / PI; } operator radianos ( ) // função conversora de tipo { return radianos(g * PI / 180.0); } ...};
  • 9. void main ( ){ graus gr, gr1(180.0); radianos rd(PI), rd1; gr = rd; // converte radianos para graus rd1 = gr1; // converte graus para radianos ...} Conversões : quando usar o quê ? Quando as duas classes são acessíveis,podemos escolher entre o uso de função conversora ou construtora. Porém se umadas classes pertencer a uma biblioteca, da qual não temos acesso ao fonte, dois casospodem acontecer . Se usarmos instruções como: • meu_obj = lib_obj;devemos implementar função construtora de um argumento. Já nas instruções: • lib_obj = meu_obj;temos que implementar função conversora de tipo. ExercíciosAssunto : Sobrecarga de Operadores. Crie uma classe que defina um número complexo x + yi, onde x e y são dotipo float e i é a raiz quadrada de -1. Defina as operações aritméticas entre númeroscomplexos nesta classe. Prática VIIIDefina uma classe chamada fração. Esta classe deve armazenar o numerador e odenominador de uma fração em duas variáveis inteiras. Inclua : a ) dois construtores: o primeiro sem argumentos e o outro que recebe numerador e denominador da fração; b) uma função-membro que retorna o numerador e outra que retorna o denominador; c) as operações de adição, subtração, multiplicação e divisão; d ) as operações de incremento e decremento pré-fixadas; e) um conversor de tipo que converte um objeto fração para um tipo float;

×