Aprendendo C/C++ Passo a Passo - Página 15

15. Passo a Passo C/C++ — Programação C++ - Sobrecarga de Operadores

Sobrecarga de Operadores

| | 1. Introdução

2. Operador
   • Regras de Sobrecarga de Operadores
   • Restrições sobre Sobrecarga de Operadores
3. Sobrecarga de Operadores Unários
4. Sobrecarga de Operadores Binários
5. Sobrecarga de Operadores com Strings |

1. Introdução

| | // Atribuir uma variável a outra
#include
using namespace std;
int main()
{
int a = 10, b;
b = a; // válido
cout << b;
return 0;
} | // Atribuir um objeto a outro
#include
using namespace std;
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;
e2 = e1; // válido
cout << endl << e2.eno << e2.sal;
return 0;
} |

As expressões são comuns em todas as linguagens; uma expressão é uma coleção de operandos e operadores. Enquanto uma operação é uma coleção de expressões.
Os dois programas acima demonstram como variáveis/objetos foram atribuídos juntos.

Ambos os programas são válidos, eles demonstram o uso do operador igual a ( = ).

| | | |

A sobrecarga de operadores é um dos recursos mais empolgantes da programação orientada a objetos. É usada para superar situações como a operação de estrutura ilegal acima. Pode transformar listagens de programas complexas e obscuras em listagens intuitivamente óbvias.

Através da sobrecarga de operadores, podemos ver como os operadores normais de C++ podem receber novos significados quando aplicados a tipos de dados definidos pelo usuário. A palavra-chave operator é usada para sobrecarregar um operador, e o operador resultante adotará o significado fornecido pelo programador.

Por exemplo, usando objetos, podemos realizar uma operação de atribuição de string direta.

| | // Programa para atribuir uma string a outra
#include
#include
#include
using namespace std;
class string
{
char str;
public:
string() { }
string(char s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1(“Computador”);
string s2;
s2 = s1;
s2.putstring();
return 0;
} |

2. Operador

tipo operator símbolo-do-operador ( lista-de-parâmetros )

A palavra-chave operator declara uma função especificando o que símbolo-do-operador significa quando aplicado a instâncias de uma classe. Isso dá ao operador mais de um significado, ou “sobrecarga”. O compilador distingue entre os diferentes significados de um operador examinando os tipos de seus operandos.

Regras de Sobrecarga de Operadores

• Você pode sobrecarregar os seguintes operadores:

| | ^= | &= | |= | << | >> | <<= | | | <= | >= | && | || | ++ | –– | | | ( ) | [ ] | new | delete | & | | | | | ~ | = | /= | %= | >>= | == | | | != | , | –> | –> | | |

• Se um operador puder ser usado como operador unário ou binário, você pode sobrecarregar cada uso separadamente.

• Você pode sobrecarregar um operador usando uma função membro não estática ou uma função global que seja amiga de uma classe. Uma função global deve ter pelo menos um parâmetro que seja do tipo de classe ou uma referência ao tipo de classe.

• Se um operador unário for sobrecarregado usando uma função membro, ele não aceita argumentos. Se for sobrecarregado usando uma função global, ele aceita um argumento.

Se um operador binário for sobrecarregado usando uma função membro, ele aceita um argumento. Se for sobrecarregado usando uma função global, ele aceita dois argumentos.

Restrições sobre Sobrecarga de Operadores

• Você não pode definir novos operadores, como **.

• Você não pode mudar a precedência ou agrupamento de um operador, nem pode mudar o número de operandos que ele aceita.

• Você não pode redefinir o significado de um operador quando aplicado a tipos de dados embutidos.

• Operadores sobrecarregados não podem aceitar argumentos padrão.

• Você não pode sobrecarregar nenhum símbolo de pré-processador, nem pode sobrecarregar os seguintes operadores:

| | . | .* | :: | ?: |

O operador de atribuição tem algumas restrições adicionais. Ele pode ser sobrecarregado apenas como uma função membro não estática, não como uma função amiga. É o único operador que não pode ser herdado; uma classe derivada não pode usar o operador de atribuição de uma classe base.

3. Sobrecarga de Operadores Unários

Vamos começar sobrecarregando um operador unário. Operadores unários atuam apenas em um operando. ( Um operando é simplesmente uma variável sobre a qual um operador atua). Exemplos de operadores unários são os operadores de incremento e decremento ++ e –, e o menos unário.

Exemplo:
O seguinte exemplo demonstra o uso do operador de incremento ++.

| | #include
using namespace std;
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count()  { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;                            // c1 = 0,  c2 = 0
cout << “\nC1 = “ << c1.get_count();       // exibir
cout << “\nC2 = “ << c2.get_count();

++c1; // c1 = 1
c2 = ++c1 ; // c1 = 2, c2 = 2

cout << “\nC1 = “ << c1.get_count();       // exibir novamente
cout << “\nC2 = “ << c2++.get_count();     // c2 = 3
return 0;
} |

Mais um exemplo para sobrecarga do menos unário.

| | #include
using namespace std;
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << “A = “ << a <<”B = “ << b;
}
void operator -()
{
a = -a; b = -b;
}
};

int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << “S : “;
s.putdata();
-s;
cout << endl << “S : “;
s.putdata();
return 0;
}
|

4. Sobrecarga de Operadores Binários

Mas os operadores podem ser sobrecarregados tão facilmente quanto os operadores unários.  Vamos olhar exemplos que sobrecarregam operadores aritméticos, operadores de comparação e operadores de atribuição aritmética.

Acabamos de ver como sobrecarregar um operador unário. O mesmo mecanismo pode ser usado para sobrecarregar um operador binário.

| | // Sobrecarga do operador +
#include
using namespace std;
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< “ : “
<< mm << “ : “ << ss;
}
time operator+(time);
};

time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}

int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
} |

5. Sobrecarga de Operadores com Strings

C/C++ lida com strings de maneira bastante diferente; nunca copiamos, concatenamos ou comparamos strings usando operadores como em outras linguagens. C/C++ possui funções embutidas para realizar as operações acima. Mas C++ fornece a facilidade de fazer tudo em strings usando operadores. Isso significa que temos que fornecer responsabilidade extra aos operadores para realizar tais coisas.

O seguinte exemplo demonstra a comparação entre duas strings usando o operador de comparação ==.

| | // Programa para comparar duas strings usando sobrecarga de operador
#include
#include
#include
using namespace std;

enum boolean{ false, true };

class string
{
char str;
public:
string() { str = NULL; }
string(char *s) { str = s; }
int operator ==(string ts)
{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};

int main()
{
string s1(“Computador”);
string s2(“Computadores”);

if(s1 == s2)
cout << “Igual”;
else
cout << “Não Igual”;

return 0;
} |

| | // concatenação de duas strings
#include
#include
#include
using namespace std;

class string
{
char str;
public:
string()
{
str = new char[30] ; str = NULL;
}
string(char *s) { str = s; }
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;
}
};

int main()
{
string s1(“Computador”); string s2(“Instituto”);
s1.putstring(); s2.putstring();
string s3;

s3 = s1 + s2;

s3.putstring();
return 0;
} |

Ref: Programação Orientada a Objetos em Turbo C++: Robert Lafore