What is Operator Overloading?

Operator overloading is one of the core features of C++, essentially granting existing operators (such as <span><span>+</span></span>, <span><span>-</span></span>, <span><span>*</span></span>, <span><span>&&</span></span>, <span><span>-></span></span> etc.) new behaviors— allowing custom types (such as classes and structures) to use operators like built-in types (<span><span>int</span></span>, <span><span>double</span></span> etc.), making the code more concise and intuitive.

In simple terms:Operator Overloading = Redefining the functionality of operators, but without changing the operator’s “precedence”, “associativity”, and “number of operands”, only altering the execution logic when applied to custom types.

1. Core Essence: Operators are “Special Functions”

In C++, all operator overloads are ultimately compiled into “function calls”, while maintaining the concise syntax of operators.

• The naming format for operator overload functions is fixed:<span><span>operator@</span></span> (where <span><span>@</span></span> represents the operator to be overloaded, such as <span><span>operator+</span></span>, <span><span>operator&&</span></span>).

• Calling method:<span><span>a @ b</span></span> is equivalent to <span><span>operator@(a, b)</span></span> (global overload) or <span><span>a.operator@(b)</span></span> (member function overload).

class Point {public:    int x, y;    // Member function overload + operator: implement addition of two Points    Point operator+(const Point& other) const {        return Point{x + other.x, y + other.y};    }};int main() {    Point a{1, 2}, b{3, 4};    Point c = a + b;  // Equivalent to a.operator+(b), concise syntax    // Without + overload, it would require: Point c = a.add(b); (verbose code)    return 0;}

Here, <span><span>a + b</span></span> is no longer the addition of built-in types, but calls <span>Point::operator+</span>, implementing the custom logic of “adding coordinates”.

2. Core Rules of Operator Overloading (Must Follow)

C++ has strict limitations on operator overloading, violations will result in compilation errors. The core rules are as follows:

1. Cannot create new operators

Can only overload existing C++ operators (such as <span>+</span>, <span>-</span>, <span>*</span>, <span>/</span>, <span>&&</span>, <span>||</span>, <span>-></span>, <span>[]</span> etc.), cannot define new operators (such as <span>@</span>, <span>#</span>, <span>$</span> etc.).

2. Cannot change the operator’s “precedence” and “associativity”

After overloading, the operator’s precedence (such as <span>*</span> higher than <span>+</span>) and associativity (such as <span>+</span> left associative) must remain consistent with built-in types and cannot be modified.For example:<span>a + b * c</span> will still compute <span>b*c</span> first, then compute <span>a + result</span>, the order will not change due to overloading.

3. Cannot change the “number of operands” of the operator

• Unary operators (such as <span>!</span> and <span>++</span>) must be overloaded with “1 operand”;
• Binary operators (such as <span>+</span> and <span>&&</span>) must be overloaded with “2 operands”;
• Exceptions:<span>()</span><span> (function call), </span><code><span>[]</span><span> (subscript access) are binary operators, but the syntax for overloading is special (the left side is the object, the right side is the parameter).</span>

4. Certain operators cannot be overloaded (fixed built-in behavior)

The following operators cannot be overloaded and can only use their native functionality:

• . (member access operator)

• .* (member pointer access operator)

• :: (scope resolution operator)

• sizeof (size operator)

• ?: (ternary conditional operator)

• typeid (type identification operator)

• const_cast/static_cast and other type conversion operators

5. Overloaded functions must include “custom types” as parameters

Cannot overload operators that only operate on built-in types (otherwise it will break native logic).For example: cannot overload <span>int operator+(int a, int b)</span> (attempting to modify <span>int</span> addition), but can overload <span>Point operator+(Point a, int b)</span> (including custom type <span>Point</span>).

3. Two Ways to Implement Operator Overloading

1. Member Function Overloading (Most Common)

• The function is a member of the class, the left operand is the “current object (<span>this</span> pointer points to)”, and the right operand is the function parameter;
• Unary operators (such as <span>!</span> and <span>++</span>) have no parameters (only operate on the current object), while binary operators (such as <span>+</span> and <span>&&</span>) have one parameter.

  class Demo {public:    bool value_;    // Member function overload unary operator !: negate    bool operator!() const {        return !value_;    }    // Member function overload binary operator &&: custom logical and    Demo operator&&(const Demo& other) const {        return Demo{value_ && other.value_};    }};// Call: Demo d{true};!d;          // Equivalent to d.operator!()d && Demo{false};  // Equivalent to d.operator&&(Demo{false})

2. Global Function Overloading (Applicable when the left operand is not the current class object)

• The function is global, both left and right operands are function parameters;
• If access to private members of the class is needed, the global overload function must be declared as a “friend function (<span>friend</span>) of the class.Example (implementing <span><span>int + Point</span></span>, where the left side is a built-in type <span><span>int</span></span>):

class Point {public:    int x, y;    // Declare friend, allowing global function to access private members (if x/y are private)    friend Point operator+(int a, const Point& p);};// Global function overload +: left side is int, right side is PointPoint operator+(int a, const Point& p) {    return Point{a + p.x, a + p.y};}// Call: Point p{1, 2};Point res = 3 + p;  // Equivalent to operator+(3, p), result x=4, y=5

4. Core Uses of Operator Overloading

The core value of operator overloading is to “make the usage of custom types closer to built-in types”, enhancing code readability and conciseness. Common scenarios include:

1. Arithmetic / Geometric operations: such as addition, subtraction, multiplication, and division of complex numbers (Complex), translation / scaling of coordinates (Point), matrix multiplication, etc.;

2. Smart pointers / Proxy classes: such as overloading -> (pointer access), * (dereference), simulating the behavior of native pointers;

3. Containers / Iterators: such as overloading [] (subscript access), ++/– (iterator movement), ==/!= (equality check);

4. Type conversion: such as overloading operator bool() (convert to boolean), operator int() (convert to integer), supporting implicit / explicit conversion of custom types.

5. Common Misconceptions (Key Pitfalls to Avoid)

1. Overloading excessively: Do not overload operators just for show; only use them when the operator’s semantics naturally match the logic of the custom type (e.g., Point’s + corresponds to adding coordinates, which is reasonable; Person’s + corresponding to “adding two people” is semantically ambiguous and not recommended);

2. Loss of special semantics: Overloading && and || will lose the native “short-circuit evaluation” feature (as seen in the previous Demo code), overloading = requires manual handling of deep copy (to avoid shallow copy issues);

3. Ignoring const correctness: When overloading operators that do not modify the object’s state (such as +, ==), the function should be marked as const (e.g., Point operator+(…) const) to avoid being unable to operate on const objects;

4. Forgetting friend declaration: If a global overload function needs to access private members of the class, it must be declared as a friend; otherwise, compilation will fail.

Custom <span><span>operator&&</span></span> loses short-circuit feature

Many developers mistakenly believe that custom <span><span>operator&&</span></span><span> can inherit short-circuit logic, but in reality, it cannot, for the following reasons:</span>

• Custom <span><span>operator&&</span></span><span> is</span><strong><span><span> a function call</span></span></strong><span><span>, and the rule of C++ function calls is "evaluate all actual parameters first, then enter the function body";</span></span>
• The native <span><span>&&</span></span><span> is</span><strong><span><span> an operator</span></span></strong><span><span>, implemented directly by the compiler with short-circuit logic (not evaluating the right-side actual parameter), which cannot be simulated through a function call.</span></span>

Conclusion

Operator overloading is C++’s “syntactic sugar” for custom types—essentially function calls, but through the concise form of operators, making the code more intuitive and readable. The core is “follow the rules, match semantics”: do not change the fundamental characteristics of operators (precedence, associativity), but endow custom types with logically consistent new behaviors.