C++ Addition

​

Unary Plus

+ expression

• Type Promotion: If the operand is a narrower integer type (e.g., char, short, bool) or an unscoped enumeration, it is promoted to int (or unsigned int). Floating-point types (e.g., float, double) and pointer types are not promoted to int.
• Pointer Decay: When applied to an lvalue of an array or function type, the unary + forces an immediate decay to a prvalue pointer type.
• Precedence: Level 3 (evaluated right-to-left).

​

Binary Addition

expression1 + expression2

• Usual Arithmetic Conversions: Before the addition occurs, C++ applies the usual arithmetic conversions to bring both operands to a common type. For example, adding an int and a double results in the int being implicitly converted to a double, yielding a double prvalue.
• Associativity: Left-to-right.
• Precedence: Level 6.

​

Pointer Arithmetic

pointer + integer
integer + pointer

• Scaling: The integral value is implicitly multiplied by the sizeof the type the pointer points to.
• Result: It yields a new pointer of the same type, offset by the scaled integer.
• Commutativity: The operation is commutative; the integer can appear on either the left or the right side of the operator.

​

Operator Overloading

class T {
public:
    // Declaration of operator+= is required to implement + in terms of +=
    T& operator+=(const T& rhs); 

    // Non-member overload
    friend T operator+(const T& lhs, const T& rhs) {
        T result = lhs;
        result += rhs; // Idiomatic: implement + in terms of +=
        return result;
    }
};

class T {
public:
    // Declaration of operator+= is required to implement + in terms of +=
    T& operator+=(const T& rhs);

    // Member overload
    T operator+(const T& rhs) const {
        T result = *this;
        result += rhs;
        return result;
    }
};

• Return Type: Overloads should return a new object by value (a prvalue), not by reference, to prevent dangling references and to adhere to the standard value-category semantics of the built-in + operator.