Post-Increment

The ++ (increment) operator is a unary operator in C++ that adds one to the value of its operand. It requires a modifiable lvalue as its operand and exists in two distinct forms: prefix and postfix. These forms differ fundamentally in their evaluation semantics, return value categories, and underlying mechanics.

Prefix Increment (++x)

The prefix form increments the operand’s value and returns an lvalue reference to the modified object.

int x = 5;
int y = ++x; // x is incremented to 6; y is assigned the new value of x (6)

Because it returns an lvalue, the result of a prefix increment can be used in expressions that require a modifiable lvalue, allowing for chaining (e.g., ++++x), though this is generally discouraged for readability.

Postfix Increment (x++)

The postfix form creates a temporary copy of the operand’s original value, increments the actual operand, and returns the temporary copy as a prvalue (pure rvalue).

int x = 5;
int y = x++; // x is incremented to 6; y is assigned the original value of x (5)

Because it returns a prvalue, the result of a postfix increment cannot be assigned to or chained (e.g., x++++ results in a compilation error).

Type-Specific Mechanics

• Integer and Floating-Point Types: The operator adds exactly 1 or 1.0 to the underlying scalar value.
• Pointers: When applied to a pointer of type T*, the operator does not simply add 1 byte to the memory address. Instead, it advances the pointer by sizeof(T) bytes, aligning it with the next contiguous element of type T in memory.
• Booleans: Applying the ++ operator to a bool was deprecated in C++98 and completely removed from the language in C++17.

Operator Overloading

When defining the ++ operator for user-defined types, C++ uses a dummy int parameter to distinguish the postfix signature from the prefix signature during overload resolution.

class Counter {
private:
    int count;

public:
    Counter(int c) : count(c) {}

    // Prefix: Returns an lvalue reference to the current object
    Counter& operator++() {
        this->count += 1;
        return *this;
    }

    // Postfix: Returns a prvalue copy of the object before modification
    // The 'int' parameter is a dummy used solely for overload resolution
    Counter operator++(int) {
        Counter temp = *this; // Copy state
        ++(*this);            // Delegate to prefix operator
        return temp;          // Return original state
    }
};

Performance Semantics

At the compiler level, for fundamental types (like int or raw pointers), modern optimizers typically emit identical machine code for both prefix and postfix forms if the return value is discarded.

However, for user-defined types, the postfix form inherently requires the allocation and construction of a temporary object to hold the prior state. Because the prefix form modifies the object in place and returns a reference, it avoids this copy overhead, making it strictly more efficient in terms of instruction count and memory access when the original value is not needed.

Master C++ with Deep Grasping Methodology!

Learn More