Overloading Arithmetic Operators for Complex Numbers

Suppose you have built a class for complex numbers, and you write a == b with two complex values. The language does not know on its own what it means for two complex numbers to be equal. A complex number has two parts, a real part and an imaginary part, and the answer depends on what you decided equality should mean for your type. This article follows a code-first approach: you will see the comparison run, predict what it returns, and then trace the definitions that produced the result.

The two operators are written as ordinary functions named operator== and operator!=. The language looks for these names when it sees the == or != symbol between two values of your class. Each one takes two complex values as its parameters and returns a bool, which is either true or false. Without a definition like this, the comparison symbol has no meaning for your type, so the program needs you to supply one.

The same idea applies to arithmetic. The language does not automatically know what it means to add two of your values or subtract one from another. Operator overloading is the mechanism that lets you attach your own behavior to an operator symbol when its operands are your type. An overloaded arithmetic operator is a function whose name is the operator symbol, such as operator+, and whose body defines what the operator means for the user-defined type.

The equality operator does not compare whole complex numbers in a single step. It asks two separate questions. First, it checks whether the real part of a equals the real part of b, using a.real() and b.real(). Second, it checks whether the imaginary part of a equals the imaginary part of b, using a.imag() and b.imag(). The two results are joined with the && operator, which means both checks must succeed for the overall result to be true.

Because the comparison uses ==, each part is compared exactly. Two complex numbers whose parts differ, even slightly, are not equal under this definition. The operator returns true only in the case where every part matches.

The inequality operator does not repeat the component checks. Its definition is return !(a==b), which first evaluates a==b and then negates the result. The source describes this as implementing inequality in terms of equality, so operator!= depends on operator== and stays consistent with it.

Trace the flow for the pair from the previous section. operator== evaluates to false, so the expression !(false) becomes true, and a != b returns true. The two operators give opposite answers for every pair, because one is literally the negation of the other.

This design has a practical consequence. If the rule for what counts as equal changes, you only need to change operator==. The inequality operator follows automatically, because it is defined in terms of the equality result.

When a comparison returns a result you did not expect, the cause is usually in one of the two definitions. Most divergences come from a single check being wrong, such as using || instead of &&, or checking only one part.

To locate a divergence, start from the operator that produced the unexpected value. If it is operator!=, look at operator== first, because the inequality result is only as correct as the equality logic it negates. Then check each part of the equality definition on its own, since a single wrong check is the most common cause.

Arguments passed by value are copied, so the function can modify its parameter freely without changing the caller's value. This is what makes the arithmetic definitions safe to write. Inside operator+, the parameter a is a copy of the caller's first value, so updating a does not touch the caller's variable.

The diagram shows the key asymmetry. The copy named a changes, while the caller's x stays as it was. The copy is the thing being updated, and the caller's x keeps its original value of 2 + 3i. The returned value is what carries the result out of the function, which is why the definition ends with a return statement rather than relying on the parameter to communicate the answer.

Start with the addition definition. Its name is operator+, and it accepts two parameters, both of type complex. The body does not compute a fresh sum in a separate variable. Instead, it applies the compound assignment a += b to the first parameter and returns the result. The body relies on a += b being meaningful for the type, which is why the compound assignment matters here.

A binary operator takes two operands, so its definition has two parameters. The source gives the same pattern for subtraction, multiplication, and division. Each body performs the matching compound assignment on the first parameter and returns it. Subtraction uses a -= b, multiplication uses a *= b, and division uses a /= b. Only the operator symbol and the compound assignment change; the structure stays the same.

A unary operator takes exactly one operand. Unary minus has a different shape from the binary definitions. Its parameter list has a single complex value, and its body does not use a compound assignment. Instead, it builds and returns a new complex value whose real part is the negation of the original real part and whose imaginary part is the negation of the original imaginary part. If a has real part $a_r$ and imaginary part $a_i$, the result is $(-a_r, -a_i)$.

The unary case shows the contrast clearly. The operand is not modified in place as a compound assignment would do. The function constructs a fresh value and hands it back, whereas in the binary definitions the copy of the first operand is the thing being updated.