• 0
Sign in to follow this  
Castro

Protótipo de função de dobrecarga de operadores

Question

:wacko:

Considere o fragmento de código

#include <iostream>
#include <cstdlib>
using namespace std;

class Sobrecarga
{
    private:
    double x,y,saida_tela;  
    public:
    //Construtor
    Sobrecarga(double valor);
    //Operadores unários
    Sobrecarrega& operator++();     //pré-incremento
    Sobrecarrega& operator++(int); //pós-incremento
    Sobrecarrega& operator--();   //pré-decremento
    Sobrecarrega& operator--(int);//pós-decremento
    //Operador binnario 
    Sobrecarrega operator+(Sobrecarrega s1);//adição
    Sobrecarrega operator-(Sobrecarrega s2);
    //função amiga para imprimir o valor de "a"
  friend ostream& operator<<(ostream& os, Sobrecarrega obj);
};
Sobrecarga Sobrecarrega::operator-(Sobrecarrega s2)
{
    Sobrecarga sub(0.0);
    sub.x= x - s2.x;
    sub.y= y - s2.y;
    sub.saida_tela = saida_tela - s2.saida_tela;
 return sub;
}
int main()
{
   Sobrecarga a(4.0);
     cout << "Saida original de \"a\"." << endl;
     cout << a << endl;
    cout << "Saidal de \"a++\"." << endl;
     a++;     
     cout << a << endl;
return(0)
}
Por que o nome da função em sobrecarga de operadores tem de ser o mesmo nome da classe para o programa compilar? O código acima não pode ser compilado. Entretanto se eu fizer:
#include <iostream>
#include <cstdlib>
using namespace std;

class Sobrecarga
{
    private:
    double x,y,saida_tela;  
    public:
    //Construtor
    Sobrecarga(double valor);
    //Operadores unários
    Sobrecarga& operator++();     //pré-incremento
    Sobrecarga& operator++(int); //pós-incremento
    Sobrecarga& operator--();   //pré-decremento
    Sobrecarga& operator--(int);//pós-decremento
    //Operador binnario 
    Sobrecarga operator+(Sobrecarga s1);//adição
    Sobrecarga operator-(Sobrecarga s2);
    //função amiga para imprimir o valor de "a"
  friend ostream& operator<<(ostream& os, Sobrecarga obj);
};
Sobrecarga Sobrecarga::operator-(Sobrecarga s2)
{
    Sobrecarga sub(0.0);
    sub.x= x - s2.x;
    sub.y= y - s2.y;
    sub.saida_tela = saida_tela - s2.saida_tela;
 return sub;
}
int main()
{
   Sobrecarga a(4.0);
     cout << "Saida original de \"a\"." << endl;
     cout << a << endl;
    cout << "Saidal de \"a++\"." << endl;
     a++;     
     cout << a << endl;
return(0)
}
Se eu escrever o programa desta forma, irá compilar corretamente. Poderiam explicar a diferença entre uma forma e outra? as funções de sobrecarga ou protótipo das funções de sobrecarga, não tem tipo de retorno como em:
double minha_ função( int v);

poderiam explicar?

Obrigado

Share this post


Link to post
Share on other sites

0 answers to this question

Recommended Posts

There have been no answers to this question yet

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Sign in to follow this