overloading Postfix oraz prefiks operatorów

Question

należy rozważyć następujący kod

#include <iostream> 
using namespace std; 
class Digit 
{ 

private: 
    int m_digit; 
public: 
    Digit(int ndigit=0){ 
    m_digit=ndigit; 
         } 
    Digit& operator++();//prefix 
    Digit& operator--(); //prefix 
     Digit operator++(int); 
     Digit operator--(int); 
     int get() const { return m_digit;} 
}; 
Digit& Digit::operator++(){ 

    ++m_digit; 
    return *this; 
} 
Digit& Digit::operator--(){ 
--m_digit; 
return *this; 

} 
Digit Digit::operator++(int){ 
Digit cresult(m_digit); 
++(*this); 
return cresult; 


} 
    Digit Digit::operator--(int){ 
Digit cresult(m_digit); 
--(*this); 
return cresult; 


} 
    int main(){ 

    Digit cDigit(5); 
     ++cDigit; 
     cDigit++; 
     cout<<cDigit.get()<<endl; 
     cout<<cDigit.get()<<endl; 





    return 0; 
    } 

tutaj jest realizowany dwie wersje operatorów Postfix oraz przedrostek Czytałem, że różnica jest wykonany przez wprowadzenie kolejnego tzw manekina argumentu, ale mam pytanie, czy widzimy deklarację tych

Digit& operator++();//prefix 
      Digit& operator--(); //prefix 
     Digit operator++(int); 
     Digit operator--(int); 

one różniły od & znaku, więc dlaczego konieczne jest obojętne argumentem? a także w obu przypadkach na przykład ++ operator jest napisane przed argumentem i nie oznacza to, że są one podobnie?

Answer 1

Przed i po inkrementacji są dwoma różnymi operatorami i wymagają oddzielnych przeciążeń.

C++ nie pozwala przeciążać się wyłącznie na typ zwracany, więc posiadanie różnych typów zwracania, jak w twoim przykładzie, nie wystarczyłoby do ujednoznacznienia obu metod.

Fałszywy argument jest mechanizmem, który twórca C++ wybrał do ujednoznacznienia.

Answer 2

Operator, tak jak każda funkcja, jest identyfikowany przez podpis. Typ powrotu i modyfikatory przed nazwą funkcji/operatora nie są w tym zawarte. Twoje nazwy operatorów są tutaj

operator++() 
operator++(int) 

Jest to jedyny sposób, w jaki kompilator rozróżnia te dwa. Jeśli chodzi o wartości zwracane przez Digit& i Digit; Są one potrzebne ze względu na sposób działania ++ x i x ++.

Answer 3

W funkcjach/metodach C++ nie można przeciążać typu zwracanego, tylko według listy parametrów. Ignorując fakt, że operatory prefiksów i postfiksów są operatorami, wyobraź sobie, że gdyby były zwykłymi innymi funkcjami, w jaki sposób kompilator będzie pracował na podstawie typu zwracanego? Na przykład.

int x = 2; 

const int DoIt() 
{ 
    return 1; 
} 

int& DoIt() 
{ 
    return x; 
} 

int y = DoIt(); 

Ponieważ przeciążenia operatora są po prostu funkcjami na sercu, kompilator nie może odróżnić ich za pomocą typu zwrotu.

Zobacz http://www.parashift.com/c++-faq-lite/operator-overloading.html#faq-13.14

Answer 4

w ampułko-góra/dół i po góra/dół, różnica jest tylko na podstawie fikcyjnego parametru w funkcji przeciążonej

operator++()   => Prefix Increment 
operator--()   => Prefix Decrement 

operator++(int)  => Postfix Increment 
operator--(int)  => Postfix Decrement 

zwracany typ może być taka sama. możesz również odnieść się: http://www.tutorialspoint.com/cplusplus/increment_decrement_operators_overloading.htm