> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Post-Decrement
The `--` (decrement) operator is a unary operator that subtracts exactly one from the value of its operand. The operand must be a modifiable lvalue of an arithmetic type (integer or floating-point) or a pointer to a completely-defined object type.
The operator exists in two distinct forms, which differ fundamentally in their evaluation semantics and value categories.
## Prefix Decrement (`--x`)
The prefix form decrements the value of the operand and yields an **lvalue** identifying the modified object.
```cpp theme={"dark"}
--operand;
```
**Semantics:**
1. The value of `operand` is decreased by 1.
2. The expression evaluates to the updated `operand` as an lvalue.
3. Because it yields an lvalue, the result of a prefix decrement can be chained or assigned to. However, for fundamental types, chaining operations like `--(--x)` prior to C++11 results in strictly **Undefined Behavior** due to modifying a scalar variable twice without an intervening sequence point.
## Postfix Decrement (`x--`)
The postfix form decrements the value of the operand but yields a **prvalue** (pure rvalue) representing the value of the object *before* the modification occurred.
```cpp theme={"dark"}
operand--;
```
**Semantics:**
1. A temporary copy of `operand`'s current value is created.
2. The value of the actual `operand` is decreased by 1.
3. The expression evaluates to the temporary copy (the original value) as a prvalue.
4. For fundamental types, because the result is a prvalue of a non-class type, it cannot be assigned to or chained (e.g., `(x--)--` is a compilation error). However, for user-defined class types, a prvalue can invoke non-const member functions. Therefore, `(obj--)--` will successfully compile for a class type unless its postfix operator is explicitly lvalue-reference qualified.
## Type-Specific Mechanics
* **Arithmetic Types:** For integers and floating-point numbers, the operator performs standard subtraction of `1` or `1.0`.
* **Pointer Types:** When applied to a pointer, the decrement operation is scaled by the size of the type the pointer addresses. It subtracts `sizeof(T)` bytes from the memory address, moving the pointer backward by exactly one element of type `T`.
* **Boolean Types:** The `--` operator is strictly ill-formed when applied to operands of type `bool`.
## Operator Overloading
When defining the `--` operator for user-defined types, C++ requires distinct function signatures to differentiate between prefix and postfix resolution. The postfix version utilizes a dummy `int` parameter exclusively for overload resolution.
```cpp theme={"dark"}
class CustomType {
int data;
public:
// Prefix decrement: Returns an lvalue reference, yielding an lvalue
CustomType& operator--() {
this->data -= 1;
return *this;
}
// Postfix decrement: Returns a value type, yielding a prvalue
// Note: Can be lvalue-reference qualified (e.g., operator--(int) &) to prevent (obj--)--
CustomType operator--(int) {
CustomType temp = *this; // Copy state
this->data -= 1; // Mutate original
return temp; // Return unmodified copy
}
};
```
## Evaluation Overhead
For fundamental types, compilers trivially optimize both forms to identical machine code if the return value is discarded. However, for user-defined types, the postfix decrement inherently requires allocating a temporary object and invoking a copy constructor. Consequently, the prefix form (`--x`) is computationally cheaper and is the standard convention unless the pre-decremented state is explicitly required by the surrounding expression.
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
