C++ - Sobrecarga de Operadores Sobrecarregar um operador significa redefinir seu símbolo, de maneira que ele se 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ções chamadas 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é-fixado class ponto { private : int x, y; 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 << ) ; ; { 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
Observ.: ++p1 ; é equivalente a p1.operator++( ); Sobrecarga do operador de incremento pós-fixado : Para distinguir entre as formas pré e pós-fixada, o compilador utiliza o número de argumentos da função operadora. sem parâmetro : pré-fixado operator ++ ( ) com um parâmetro do tipo int : pós-fixadooperator ++ (int) ponto operator ++(int) { ++x; ++y; return ponto(x-1, y-1); // função operadora pós-fixada Sobrecarga de operadores binários : função operadora com um argumento. Ex.: sobrecarga do + aritmético class 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); { venda A(58, 12734.53), B(30, 6000.30), T; T = A + B; Somando objetos da classe ponto : funções operadoras class 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);
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) // errado Operadores 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;
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]; 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)
{ 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); { 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 retornar referência a uma variável automática. Conversões entre tipos básicos : implícita explícita (operdor molde) Conversão de tipos com classes : double dvar = 'A'; double dvar = double ('A'); 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>
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) { itoa(n, str, 10); ; void main ( ) { string s; s = 5392; // sobrecarga do operador de atribuição // conversão de inteiro para string objeto a objeto (classes diferentes ) - obja = objb Dois métodos : função-membro conversora da classe B construtor membro da classe A Primeiro método : função conversora Classes graus e radianos. Converter objetos da classe radianos em objetos da classe graus (grau = radiano). Função conversora na classe radianos.
#include <iostream.h> #include <iomanip.h> #define PI 3.141592653 class graus { private : double g; graus (double x) { g=x; graus ( ) { g = 0; void print( ) { cout << setiosflags (ios :: fixed) << setiosflags (ios :: showpoint) << setprecision (2) << g << \xf8\n ; ; class radianos { private: double rad; radianos (double r) { rad = r ; radianos ( ) {rad = 0.0 ; ; { graus gr; radianos rd(pi); gr = rd; operator graus ( ) { return graus(180.0*rad/pi); void print( ) { cout << setioflags (ios :: fixed) << setiosflags (ios :: showpoint) << setprecision (2) << rad << rad \n ; // função conversora de rad. para graus // converte radianos para graus Segundo método : função construtora (implementada na classe graus)
class radianos { double getrad ( ) {return rad; ; class graus { graus (radianos rd) // construtor para conversão { g = (180.0 * rd.getrad( ) / PI; ; { 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 { 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);
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 uma das classes pertencer a uma biblioteca, da qual não temos acesso ao fonte, dois casos podem 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ícios Assunto : Sobrecarga de Operadores. Crie uma classe que defina um número complexo x + yi, onde x e y são do tipo float e i é a raiz quadrada de -1. Defina as operações aritméticas entre números complexos nesta classe. Prática VIII Defina uma classe chamada fração. Esta classe deve armazenar o numerador e o denominador 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;