Pre-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 modifies the state of that operand directly. The operator exists in two distinct forms—prefix and postfix—which differ fundamentally in their evaluation semantics, sequencing, and resulting value categories.

Prefix Increment (++x)

The prefix form increments the value of the operand and evaluates to the newly incremented value.

• Value Category: It returns an lvalue reference to the modified object.
• Semantics: The increment operation is sequenced before the value computation of the expression.

int x = 5;
int y = ++x; // x is incremented to 6; y is initialized with the value of x (6).

Postfix Increment (x++)

The postfix form evaluates to the original value of the operand, and then increments the operand’s value as a side effect.

• Value Category: It returns a prvalue (pure rvalue) representing a temporary copy of the object’s state prior to the increment.
• Semantics: The value computation of the expression is sequenced before the modification of the operand.

int a = 5;
int b = a++; // a is incremented to 6; b is initialized with the prvalue copy (5).

Pointer Arithmetic Semantics

When the operand is a pointer to a completely defined type T, the ++ operator does not simply add the literal integer 1 to the raw memory address. Instead, it advances the pointer to the next contiguous element in memory by adding sizeof(T) bytes to the underlying address. This ensures the pointer correctly aligns with the memory layout of the type it points to.

#include <cstdint>

std::int32_t* ptr = reinterpret_cast<std::int32_t*>(0x1000);
ptr++; // Advances by sizeof(std::int32_t) (4 bytes). ptr is now 0x1004.

Boolean Operands

Applying the increment operator to an operand of type bool is invalid in modern C++. While historically permitted (where it would unconditionally set the boolean to true), this behavior was deprecated in C++98 and completely removed from the language in C++17. Attempting to use ++ on a bool in C++17 or later results in a compilation error.

Operator Overloading

When implementing the ++ operator for user-defined types (classes or structs), the compiler distinguishes between the prefix and postfix forms via their function signatures. The postfix overload requires a dummy int parameter, which the compiler automatically passes as 0 during invocation.

class Counter {
private:
    int value;

public:
    Counter(int v) : value(v) {}

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

    // Postfix: Returns a prvalue copy. Requires the dummy 'int' parameter.
    Counter operator++(int) {
        Counter temp = *this; // 1. Copy the original state
        ++(*this);            // 2. Increment the current object (delegating to prefix)
        return temp;          // 3. Return the unmodified copy
    }
};

Performance Mechanics

Because the postfix form requires the instantiation of a temporary object to hold the pre-increment state, it incurs overhead for non-primitive types. The prefix form avoids this copy operation entirely. Consequently, prefix increment is the mechanically optimal choice for iterators and complex objects unless the original value is explicitly required by the surrounding expression.

Sequencing and Evaluation Order

The ++ operator introduces side effects by modifying the operand. Modifying the same scalar object multiple times within a single expression without an intervening sequence point requires strict adherence to C++ evaluation rules to avoid Undefined Behavior (UB).

• Pre-C++17: Expressions like i = i++ or arr[i] = i++ invoked strict Undefined Behavior due to unsequenced modifications.
• C++17 and later: The evaluation order rules were refined. The right-hand side of an assignment is now strictly sequenced before the left-hand side, making i = i++ well-defined (the assignment overwrites the increment). Furthermore, function arguments are now indeterminately sequenced rather than unsequenced. This guarantees that one argument is fully evaluated (including its side effects) before the next one begins. Therefore, passing multiple increments to a function, such as f(i++, i++), no longer invokes Undefined Behavior; it results in unspecified behavior (the compiler can choose which argument to evaluate first, but their evaluations will not overlap).

Master C++ with Deep Grasping Methodology!

Learn More