Quá tải tăng trước C++

Ví dụ sau giải thích cách toán tử gia tăng (++) có thể được nạp chồng cho việc sử dụng tiền tố cũng như hậu tố. Tương tự, bạn có thể nạp chồng toán tử (--)

#include 
using namespace std;
 
class Time {
   private:
      int hours;             // 0 to 23
      int minutes;           // 0 to 59
      
   public:
      // required constructors
      Time() {
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m) {
         hours = h;
         minutes = m;
      }
      
      // method to display time
      void displayTime() {
         cout << "H: " << hours << " M:" << minutes <= 60) {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      
      // overloaded postfix ++ operator
      Time operator++( int ) {
      
         // save the orignal value
         Time T(hours, minutes);
         
         // increment this object
         ++minutes;                    
         
         if(minutes >= 60) {
            ++hours;
            minutes -= 60;
         }
         
         // return old original value
         return T; 
      }
};

int main() {
   Time T1(11, 59), T2(10,40);
 
   ++T1;                    // increment T1
   T1.displayTime();        // display T1
   ++T1;                    // increment T1 again
   T1.displayTime();        // display T1
 
   T2++;                    // increment T2
   T2.displayTime();        // display T2
   T2++;                    // increment T2 again
   T2.displayTime();        // display T2
   return 0;
}

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau -

H: 12 M:0
H: 12 M:1
H: 10 M:41
H: 10 M:42

Bạn nạp chồng toán tử tăng tiền tố ++ bằng toán tử hàm không phải thành viên có một đối số loại lớp hoặc tham chiếu đến loại lớp hoặc bằng toán tử hàm thành viên không có đối số

Trong ví dụ sau, toán tử gia số bị quá tải theo cả hai cách.

class X {
public:

  // member prefix ++x
  void operator++() { }
};

class Y { };

// non-member prefix ++y
void operator++(Y&) { }

int main() {
  X x;
  Y y;

  // calls x.operator++()
  ++x;

  // explicit call, like ++x
  x.operator++();

  // calls operator++(y)
  ++y;

  // explicit call, like ++y
  operator++(y);
}

Toán tử gia số hậu tố ++ có thể được nạp chồng cho một loại lớp bằng cách khai báo một toán tử hàm không phải thành viên operator++() với hai đối số, đối số thứ nhất có loại lớp và đối số thứ hai có loại int. Ngoài ra, bạn có thể khai báo toán tử hàm thành viên operator++() với một đối số có kiểu int. Trình biên dịch sử dụng đối số int để phân biệt giữa các toán tử gia tăng tiền tố và hậu tố. Đối với các cuộc gọi ẩn, giá trị mặc định bằng không

Bạn có thể quá tải += trong CPP không?

++ i ++ có hợp lệ trong C không?

Toán tử ++ có thể bị quá tải không?

Bạn có thể tăng với ++ trong C không?