Solucionado (ver solução)
Solucionado
(ver solução)
1
resposta

[Dúvida] Operator Overloading, erro apenas no mesmo escopo?

Fiz alguns testes com este problema de overloading, e pude constatar que a necessidade de cast só ocorre em usos no mesmo escopo, e não na implementação.

Salvei um git com os exemplos, também colocarei os trechos do meu código aqui.

Primeiro tive o erro demonstrado na aula, nas linhas 63 e 96 dos links abaixo:

63: https://github.com/adrianowead/estudo-cpp/blob/6104d92104688e27bdcdaabc6957fa2f676742a5/src/Banco/Banco/main.cpp#L63

(Banco::Conta&) corrente1 += 90;

96: https://github.com/adrianowead/estudo-cpp/blob/6104d92104688e27bdcdaabc6957fa2f676742a5/src/Banco/Banco/main.cpp#L96

corrente3 += corrente2;

Como experimento eu propositalmente dupliquei o código e usei em conta poupança, que para a minha surpresa não deu erro, e assim não precisei de cast, isso na linha: 111: https://github.com/adrianowead/estudo-cpp/blob/6104d92104688e27bdcdaabc6957fa2f676742a5/src/Banco/Banco/main.cpp#L111

poupanca2 += poupanca1;

Ai veio a dúvida, a linguagem não permite uso dos dois tipos baseado unicamente no escopo?

Então fiz uma função de testes na linha 28: https://github.com/adrianowead/estudo-cpp/blob/6104d92104688e27bdcdaabc6957fa2f676742a5/src/Banco/Banco/main.cpp#L28

void testarOperatorEmOutroEscopo(Banco::Conta& conta)
{
    conta += 90;
}

E consumi ela na linha 67 utilizando a mesma conta corrente em que foi necessário o cast: https://github.com/adrianowead/estudo-cpp/blob/6104d92104688e27bdcdaabc6957fa2f676742a5/src/Banco/Banco/main.cpp#L67

testarOperatorEmOutroEscopo(corrente1);

E sim, o erro ocorre então ao utilizar o operador overload da classe base Conta, misturado com a implementação das classes filhas. Mas não só isso, se o mesmo tipo de filha usar as duas implementações. Ou seja, se no mesmo escopo a conta corrente usar apenas uma das implementações, não haverá qualquer conflito.

Então para evitar a necessidade de cast, basta direcionar os usos para escopos distintos.

Apesar da constatação, vou deixar postado aqui como dúvida, pois como ainda não manjo muito da linguagem não sei se a análise está correta.

1 resposta
solução!

Olá, Adriano!

Pelo que entendi, você está tentando entender por que o operador de sobrecarga funciona em alguns casos e não em outros, certo? Vou tentar esclarecer isso para você.

A sobrecarga de operadores em C++ é um recurso que permite que operadores sejam redefinidos e usados em classes personalizadas. No entanto, há algumas regras que devem ser seguidas.

No caso do seu código, o operador += foi sobrecarregado para a classe Conta para aceitar um valor float e para a classe ContaCorrente para aceitar um objeto ContaCorrente. Isso significa que, quando você tenta usar o operador += em um objeto ContaCorrente com um valor float, o compilador não sabe qual versão do operador usar, pois ambas as classes têm uma versão sobrecarregada do operador.

Quando você usa o operador += em um objeto ContaCorrente com outro objeto ContaCorrente (como em corrente3 += corrente2;), o compilador sabe usar a versão sobrecarregada do operador na classe ContaCorrente, pois é a única versão que aceita um objeto ContaCorrente como argumento.

No caso de poupanca2 += poupanca1;, o compilador usa a versão sobrecarregada do operador na classe Conta, pois a classe ContaPoupanca não tem uma versão sobrecarregada do operador que aceita um objeto ContaPoupanca.

Quando você tenta usar o operador += em um objeto ContaCorrente com um valor float no mesmo escopo em que o operador foi sobrecarregado para aceitar um objeto ContaCorrente (como em (Banco::Conta&) corrente1 += 90;), você precisa fazer um cast para a classe Conta para indicar ao compilador para usar a versão sobrecarregada do operador na classe Conta.

No entanto, quando você usa o operador += em um objeto ContaCorrente com um valor float em um escopo diferente (como na função testarOperatorEmOutroEscopo), o compilador usa a versão sobrecarregada do operador na classe Conta, pois é a única versão que aceita um valor float como argumento.

Espero que isso esclareça suas dúvidas sobre a sobrecarga de operadores em C++. Lembre-se, a sobrecarga de operadores é um recurso poderoso, mas também pode ser confuso e levar a erros se não for usado corretamente. Sempre certifique-se de que está claro qual versão do operador está sendo usada em cada situação.

Espero ter ajudado e bons estudos!