Using the Complex Number Class

When you write an expression such as c!=b or 1/a, it looks exactly like the expressions you would write for ordinary numbers. The symbols seem to be built-in instructions that the language already knows how to carry out. When one of the operands is a complex number, that impression stops being reliable. The compiler does not treat the symbol as a simple built-in instruction. It treats the operator as a request to call a function. This article shows how that translation works and why reading the translated form is the key to reasoning about complex number expressions.

Take the source's first example, c!=b. When c or b is a complex number, the compiler does not read != as an ordinary comparison instruction. It reads it as a request for the operator!= function, and it passes the two operands to that function. The expression is therefore equivalent to operator!=(c,b). The name of the function is the operator with the word operator placed in front of it. The operands keep the same order they had in the original expression, so c is still the first argument and b is still the second.

The rule has three parts. First, the operator symbol becomes the name of a function by placing the word operator in front of it, so != becomes operator!= and / becomes operator/. Second, the operands become the arguments of that function, enclosed in parentheses and separated by commas. Third, the operands keep their original order. The converted form is an ordinary function call, so once you can read it, you can see exactly which values the operation receives and in what sequence. This matters because some operators depend on which operand is on the left and which is on the right. Division is the clearest case.

The second source example, 1/a, shows a step that is easy to miss. The rule gives operator/(complex{1},a). The function is operator/, and its first argument is complex{1}, not the bare 1. The left operand was itself converted into a complex value before the call was made. So the plain integer 1 does not reach the division function as a plain integer. It arrives as a complex object, and that object is what the division function receives first. The right operand a is passed through as the second argument.

The same pattern applies to comparison operators, not just arithmetic ones. Consider a generated example with two complex variables named x and y, written as x!=y. The compiler reads the != symbol as a request for the operator!= function and passes the operands in their original order. The expression therefore corresponds to operator!=(x,y). The left operand x remains the first argument, so the order of the variables in the original expression determines the order of the call.