Почему в приведенном ниже коде возвращаемый тип используется для перегрузки операторов?

Question

Я пытался понять перегрузку операторов и не использовал тип возвращаемого значения как тип класса в приведенной ниже программе: когда я переключаю тип возвращаемого значения с перегрузкой на int, он работает нормально.

#include <iostream>
using namespace std; 

class overload { 
private: 
    int count; 

public: 
    overload(int i) 
        : count(i) 
    { 
    } 

    overload operator++(int) //why return type is class type when i can use int
    { 
        return (count++); 
    } 
    overload operator++() //why return type is class type when i can use int
    { 
            count = count + 1; 
            return count;        
    } 
    void Display() 
    { 
        cout << "Count: " << count<<endl; 
    } 
}; 
// Driver code 
int main() 
{ 
    overload i(5); 
    overload post(5); 
    overload pre(5); 

    // this calls "function overload operator ++()" function 
    pre = ++i; 
    post = i++; 
    i.Display(); 
    return 0; 
}

Answer 1

Разница между операторами до / после инкремента заключается в том, что один работает непосредственно с объектом (pre-increment: ++ foo), и нужно взять копию объекта и вернуть ее (post increment: foo ++).Немного более подробный способ написать это будет:

// return a new object that represents the old value
overload operator++(int)
{ 
    overload oldValue(count); // take copy
    count++;                  // increment this object
    return oldValue; 
} 

// increment the count, and return a reference to this object
overload& operator++()
{ 
    ++count;
    return *this;        
} 

Пока вы могли бы вернуть int (не делайте этого!) , это приведет только кдо путаницы.Фактически это приведет к нескольким проблемам с кодом, таким как:

overload foo = ++someOtherFoo;

, который, если вы вернете int из ++, в конечном итоге вызовет функцию конструктора (а не конструктор копирования) для создания новогообъект.то есть

overload foo = overload(++someOtherFoo);

Этот конструктор может не быть доступным, и поэтому код завершится ошибкой.

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

operator int () const
{ 
  return count; 
}

Answer 2

Нет ограничений на тип возврата перегруженного оператора.Здесь это также может быть int.Код, который вы показываете, имеет тип класса в качестве возвращаемого типа, чтобы облегчить другие операторы в коде, как показано ниже, если когда-либо конструктор класса overload помечен explicit;

Например, с помощью:

explicit overload(int i) 
        : count(i) 
{ 
} 

и

int operator++(int) //return type is  int
{ 
    return (count++); 
} 
int operator++() //return type is int
{ 
     count = count + 1; 
     return count;        
} 

Следующее не удастся скомпилировать:

pre = ++i; //will not work
post = i++; //will not work

Это связано с тем, что оператор неявного копирования больше не будет пригоден для преобразования из int до const overload.

См. Демонстрация

Обратите внимание, что Канонические реализации приращения префикса и постфикса /операторы декремента возвращают overload& и overload соответственно.

Хотя каноническая форма предварительного увеличения / предварительного уменьшения возвращает ссылку, как и при любой перегрузке оператора, returnтип определяется пользователем ;например перегрузки этих операторов для std :: atomic возвращаются значением