102 lines
3.2 KiB
Markdown
102 lines
3.2 KiB
Markdown
|
---
|
||
|
title: C++ Overloading
|
||
|
localeTitle: Sobrecarga C ++
|
||
|
---
|
||
|
C ++ permite que você especifique mais de uma definição para um nome de função ou um operador no mesmo escopo, o que é chamado de sobrecarga de função e sobrecarga de operador, respectivamente.
|
||
|
|
||
|
Uma declaração sobrecarregada é uma declaração que é declarada com o mesmo nome que uma declaração declarada anteriormente no mesmo escopo, exceto que ambas as declarações possuem argumentos diferentes e obviamente uma definição diferente (implementação).
|
||
|
|
||
|
Quando você chama uma função ou operador sobrecarregado, o compilador determina a definição mais apropriada a ser usada, comparando os tipos de argumento que você usou para chamar a função ou operador com os tipos de parâmetro especificados nas definições. O processo de seleção da função ou operador sobrecarregado mais apropriado é chamado de resolução de sobrecarga.
|
||
|
|
||
|
### Sobrecarga de função em C ++
|
||
|
|
||
|
Você pode ter várias definições para o mesmo nome de função no mesmo escopo. A definição da função deve diferir uma da outra pelos tipos e / ou pelo número de argumentos na lista de argumentos. Você não pode sobrecarregar as declarações de função que diferem apenas pelo tipo de retorno.
|
||
|
|
||
|
A seguir, o exemplo em que a mesma função print () está sendo usada para imprimir diferentes tipos de dados -
|
||
|
|
||
|
```cpp
|
||
|
#include <iostream>
|
||
|
#include <string>
|
||
|
using namespace std;
|
||
|
|
||
|
class printData {
|
||
|
public:
|
||
|
void print(int i) {
|
||
|
cout << "Printing int: " << i << endl;
|
||
|
}
|
||
|
void print(double f) {
|
||
|
cout << "Printing float: " << f << endl;
|
||
|
}
|
||
|
void print(const string& s) {
|
||
|
cout << "Printing string: " << s << endl;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
int main() {
|
||
|
printData pd;
|
||
|
|
||
|
// Call print to print integer
|
||
|
pd.print(5);
|
||
|
|
||
|
// Call print to print float
|
||
|
pd.print(500.263);
|
||
|
|
||
|
// Call print to print string
|
||
|
pd.print("Hello C++");
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Quando o código acima é compilado e executado, ele produz o seguinte resultado -
|
||
|
```
|
||
|
Printing int: 5
|
||
|
Printing float: 500.263
|
||
|
Printing string: Hello C++
|
||
|
```
|
||
|
|
||
|
### Sobrecarga de Operador em C ++
|
||
|
|
||
|
A maioria dos operadores internos também pode ser sobrecarregada em C ++. Isso permite que os programadores atribuam implementações diferentes aos operadores, dependendo dos argumentos. Esses operadores sobrecarregados podem trabalhar para classes definidas pelo usuário.
|
||
|
```
|
||
|
#include<iostream>
|
||
|
using namespace std;
|
||
|
|
||
|
class Complex_Number{
|
||
|
private:
|
||
|
int real;
|
||
|
int imag;
|
||
|
public:
|
||
|
Complex_Number(int i = 0, int j =0)
|
||
|
{
|
||
|
real = i;
|
||
|
imag = j;
|
||
|
}
|
||
|
//Here the operator '+' is being overloaded
|
||
|
Complex_Number operator + (Complex_Number const &a)
|
||
|
{
|
||
|
Complex_Number x;
|
||
|
x.real = real + a.real;
|
||
|
x.imag = imag + a.imag;
|
||
|
return x;
|
||
|
}
|
||
|
void print()
|
||
|
{
|
||
|
cout<<real<<" + i"<<imag<<endl;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
int main()
|
||
|
{
|
||
|
Complex_Number c1(3, 2), c2(1, 1);
|
||
|
//Here, the overloaded operator is called. The numbers get added according to the function defined
|
||
|
Complex_Number c3 = c1 + c2;
|
||
|
c3.print();
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Saída para o programa acima
|
||
|
```
|
||
|
4 + i3
|
||
|
|
||
|
```
|