Unary Minus

The - operator in C++ functions as both a unary negation operator and a binary arithmetic subtraction operator, depending on the lexical context and the number of operands provided. In both forms, the built-in operator evaluates to a prvalue (pure rvalue).

Unary Minus (Negation)

The unary - operator computes the algebraic negation of its single operand.

Syntax:

-expression

Mechanics:

1. Integral Types: If the operand is of an integral or unscoped enumeration type, it undergoes integral promotion before the operation (e.g., a short or char is promoted to int). The type of the result is the promoted type.
2. Floating-Point Types: If the operand is of a floating-point type, it does not undergo integral promotion. The result type remains the original floating-point type.
3. Unsigned Behavior: If the promoted type is an unsigned integer, the operation is well-defined and computes the two’s complement negation. Specifically, -x for an unsigned type evaluates to $2^n - x$ (where $n$ is the number of bits in the promoted type), effectively wrapping around.

Binary Subtraction

The binary - operator computes the difference between its left-hand side (lhs) and right-hand side (rhs) operands. It features left-to-right associativity.

Syntax:

lhs - rhs

Mechanics:

1. Usual Arithmetic Conversions: If both operands are of arithmetic or unscoped enumeration types, the compiler applies the usual arithmetic conversions to yield a common type, which becomes the result type. Scoped enumerations (enum class) do not undergo usual arithmetic conversions and do not support the built-in - operator.
2. Floating-Point: For floating-point types, it performs IEEE 754 subtraction (or the architecture’s equivalent).

Pointer Arithmetic

The binary - operator has specialized semantics when interacting with pointers. For any pointer arithmetic to be well-formed, the pointed-to type T must be a completely-defined object type. Pointer arithmetic on void* or pointers to incomplete types is ill-formed in standard C++.

Pointer minus Integer: Subtracting an integral type from a pointer yields a new pointer of the same type. The memory address is decremented by the integer value multiplied by sizeof(T). The resulting decremented pointer must remain within the bounds of the same array object (or one past the end). If the arithmetic results in a pointer outside these bounds, it invokes undefined behavior.

T* ptr = /* ... */;
T* decremented_ptr = ptr - 3; // Moves backward by 3 * sizeof(T) bytes

Pointer minus Pointer: Subtracting two pointers of the same type (ignoring cv-qualifiers) yields the distance between them in terms of the number of elements, not bytes.

• The result is a signed integer of type std::ptrdiff_t (defined in <cstddef>).
• Both pointers must point to elements of the same array object (or one past the end); otherwise, the behavior is undefined.

T* ptr1 = /* ... */;
T* ptr2 = /* ... */;
std::ptrdiff_t distance = ptr2 - ptr1;

Operator Overloading

For user-defined types (classes and structs), the - operator can be overloaded to define custom negation or subtraction semantics. It can be implemented as either a member function or a non-member (friend) function.

Unary Overload Signatures:

class T {
public:
    // Member function (no parameters, operates on *this)
    T operator-() const; 
};

// Non-member function (one parameter)
T operator-(const T& op);

Binary Overload Signatures:

class T {
public:
    // Member function (one parameter for rhs, *this is lhs)
    T operator-(const T& rhs) const; 
};

// Non-member function (two parameters)
// Preferred for binary operators to allow symmetric implicit conversions
T operator-(const T& lhs, const T& rhs);

Master C++ with Deep Grasping Methodology!

Learn More