перегрузка постфиксных и префиксных операторов

Question

пожалуйста, рассмотрите следующий код

#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;
    }

здесь реализованы две версии постфиксных и префиксных операторов, я прочитал, что разница заключается в введении другого так называемого фиктивного аргумента, но у меня есть вопрос, если мы увидим объявлениеиз этих

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

они отличаются от & mark, так зачем нужен фиктивный аргумент? а также в обоих случаях оператор example ++ записывается перед аргументом и не означает, что они одинаковы

Answer 1

Предварительное и постинкрементное вычисление - это два разных оператора, которые требуют отдельных перегрузок.

C ++ не допускает перегрузку только для возвращаемого типа, поэтому использование разных типов возврата, как в вашем примере, не будетдостаточно для устранения неоднозначности двух методов.

Пустой аргумент - это механизм, который разработчик C ++ выбрал для устранения неоднозначности.

Answer 2

Оператор, как и любая функция, идентифицируется подписью. Тип возвращаемого значения и модификаторы перед именем функции / оператора не включены в это. Имена ваших операторов здесь

operator++()
operator++(int)

Это единственный способ, которым компилятор различает их. Что касается возвращаемых значений Digit& и Digit; Они необходимы из-за того, что ++ x и x ++ должны работать.

Answer 3

В C ++ функции / методы не могут быть перегружены типом возвращаемого значения, только списком параметров.Игнорируя тот факт, что префиксные и постфиксные операторы являются операторами, представьте себе, если бы они были просто простыми другими функциями, как бы компилятор мог решить, что использовать в зависимости от типа возвращаемого значения?Например,

int x = 2;

const int DoIt()
{
    return 1;
}

int& DoIt()
{
    return x;
}

int y = DoIt();

Поскольку перегрузки операторов на самом деле просто функции в глубине души, компилятор не может различить их по типу возвращаемого значения.

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

Answer 4

В пре-инкременте / декременте и пост-инкременте / декременте разница основана только на фиктивном параметре в перегруженной функции

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

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

тип возврата может быть таким же. Вы также можете сослаться: http://www.tutorialspoint.com/cplusplus/increment_decrement_operators_overloading.htm