Pre-Increment

The ++ (increment) operator is a unary arithmetic operator in C that adds 1 to the value of its operand. It requires a modifiable lvalue of a real or pointer type. For pointer types, the operand must be a pointer to a complete object type (excluding function pointers and pointers to incomplete types like void) so that the byte size required for pointer arithmetic is strictly defined. The operator mutates the operand directly and exists in two distinct syntactic forms: prefix and postfix.

Evaluation Semantics and Value Category

The position of the operator relative to the operand dictates the order of evaluation between the expression’s yielded value and the side effect of the incrementation. Crucially in C, the result of both the prefix and postfix ++ operators is an rvalue (not an lvalue). This prevents the result from being assigned to or having its address taken.

• Prefix (++x): The operand is incremented first. The expression evaluates to the new, incremented value of the operand as an rvalue.
• Postfix (x++): The expression evaluates to the original value of the operand as an rvalue. The side effect of incrementing the operand is guaranteed to occur before the next sequence point, but after the original value is yielded.

int a = 10;
int b = ++a; // Prefix: 'a' is incremented to 11. 'b' is assigned 11.

int x = 10;
int y = x++; // Postfix: 'y' is assigned 10. 'x' is incremented to 11.

// Rvalue constraints in C:
++x = 5;     // Error: expression is not an assignable lvalue
&++x;        // Error: cannot take the address of an rvalue

Type-Specific Behavior

The underlying arithmetic behavior changes depending on the operand’s specific type:

• Real Types (Integer and Floating-Point): The operator performs standard arithmetic addition, adding exactly 1 or 1.0 to the operand.
• Pointer Types: The operator performs pointer arithmetic. It increments the memory address stored in the pointer by the size of the complete object type it points to, effectively advancing the pointer to the next contiguous element of that type. It adds sizeof(*operand) bytes to the address. Pointer arithmetic is only strictly defined when the pointer points to an element of an array object or one past the last element.

double d = 3.14;
d++; // d becomes 4.14

int arr[2] = {10, 20};
int *ptr = arr;
ptr++; // ptr advances by sizeof(int) bytes, now pointing to arr[1]

void *vptr = arr;
vptr++; // Error: cannot increment a pointer to an incomplete type

Constraints and Undefined Behavior

The ++ operator is subject to strict language constraints regarding memory modification and sequence points:

1. Lvalue Requirement: The operand itself must be a modifiable lvalue. Applying ++ to an rvalue results in a compilation error.

++5;           // Error: lvalue required
++(a + b);     // Error: lvalue required

2. Sequence Points: The C standard dictates that a scalar object shall have its stored value modified at most once by the evaluation of an expression between two sequence points. Applying the ++ operator multiple times to the same variable within a single unsequenced expression results in Undefined Behavior (UB).

int i = 0;
i = i++;           // Undefined Behavior
int j = ++i + i++; // Undefined Behavior

Master C with Deep Grasping Methodology!

Learn More