How to Overload ++ Operator in C++: Syntax and Example

In C++, you overload the ++ operator by defining a member or friend function named operator++. For prefix increment, use operator++(), and for postfix increment, use operator++(int) with an int parameter to distinguish it.

Syntax

To overload the ++ operator in C++, define two versions inside your class:

• Prefix increment: Type& operator++(); increments and returns the updated object.
• Postfix increment: Type operator++(int); increments but returns the original value before increment.

The int parameter in postfix is a dummy to differentiate it from prefix.

cpp

class MyClass {
public:
    // Prefix increment
    MyClass& operator++() {
        // increment logic
        return *this;
    }

    // Postfix increment
    MyClass operator++(int) {
        MyClass temp = *this;
        // increment logic
        return temp;
    }
};

Example

This example shows how to overload both prefix and postfix ++ operators for a simple counter class. It demonstrates how prefix increments the value and returns the updated object, while postfix returns the original value before increment.

cpp

#include <iostream>

class Counter {
private:
    int value;
public:
    Counter(int v = 0) : value(v) {}

    // Prefix ++
    Counter& operator++() {
        ++value; // increment value
        return *this; // return updated object
    }

    // Postfix ++
    Counter operator++(int) {
        Counter temp = *this; // save current state
        ++value; // increment value
        return temp; // return old state
    }

    int getValue() const { return value; }
};

int main() {
    Counter c(5);
    std::cout << "Initial: " << c.getValue() << "\n";

    ++c; // prefix
    std::cout << "After prefix ++: " << c.getValue() << "\n";

    c++; // postfix
    std::cout << "After postfix ++: " << c.getValue() << "\n";

    Counter c2 = c++; // c2 gets old value
    std::cout << "c2 (postfix result): " << c2.getValue() << "\n";
    std::cout << "c after postfix: " << c.getValue() << "\n";

    return 0;
}

Output

Initial: 5
After prefix ++: 6
After postfix ++: 7
c2 (postfix result): 7
c after postfix: 8

Common Pitfalls

Common mistakes when overloading ++ include:

• Not distinguishing prefix and postfix by missing the int parameter in postfix.
• Returning by value in prefix overload, which is less efficient; prefix should return by reference.
• Modifying the object incorrectly or forgetting to return the correct value.

Here is a wrong and right way to overload prefix ++:

cpp

class Wrong {
public:
    // Wrong: prefix returns by value
    Wrong operator++() {
        // increment logic
        return *this;
    }
};

class Right {
public:
    // Correct: prefix returns by reference
    Right& operator++() {
        // increment logic
        return *this;
    }
};

Quick Reference

Remember these points when overloading ++:

• Prefix: Type& operator++() increments and returns updated object by reference.
• Postfix: Type operator++(int) increments but returns original value by value.
• Use a dummy int parameter to distinguish postfix.
• Implement postfix by saving current state, incrementing, then returning saved state.

Key Takeaways

Overload prefix ++ as operator++() returning a reference to the updated object.

Overload postfix ++ as operator++(int) returning the original value before increment.

Use the dummy int parameter to distinguish postfix from prefix ++.

Prefix ++ should be more efficient by returning a reference, not a copy.

Always return the correct object state to avoid unexpected behavior.