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

[Castro]

: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