Compound Assignment Operators

Many programs change a variable based on its own current value. A counter goes up by one, a running total grows by some amount, and a number gets scaled. Each of these updates reads the variable, combines it with something, and stores the result back in the same variable.

Besides the usual arithmetic and logical operators, C++ provides operators written specifically for modifying a variable in place. These are compound assignment operators. They are concise, convenient, and very frequently used, so once you can read them you will see them in a large share of real code. As you work through this article, keep one question in mind: when a statement changes a variable, which value is read, and which value is written back?

Before defining anything, watch a variable change. The program below is a small illustration written for this article. It is not the program behind the verified run described later. It starts a variable x at 10, adds 5 to it with the += operator, multiplies it by 2 with the *= operator, and prints x after each change.

Read the trace from top to bottom. The first printed line is 15 because the statement x += 5 ran before the first output statement. The second printed line is 30 because x *= 2 ran before the second output statement. Each printed value comes from the most recent statement that changed x. This matching of output lines to statements is the skill you will use on longer programs.

The source's own verified run printed five lines: 15, 12, 24, 6.0, and 2.0. The listing that produced those lines is not reproduced in the material this article is built from, so this article does not attempt to reconstruct it. The approach you just used, following the value through each statement, is the same approach you would apply to that run.

A compound assignment combines an operator with the equals sign, so that one statement both computes a new value and stores it back into the same variable. The forms the source lists are x += y, x -= y, x *= y, x /= y, and x %= y. The source also lists the increment and decrement forms ++x and --x.

The source defines x += y as x = x + y. The same rule applies to the other operators: replace the plus sign with minus, asterisk, slash, or percent, and the reading stays the same. The variable on the left is updated using its own current value and the value on the right. To read any compound statement, rewrite it in the form x = x op y, where op stands for the operator, and then the variable on the left is clearly updated from its current value.

Notice that the variable on the left appears on both sides of the rewritten form. That is why the statement changes the variable: it is read first, combined with y, and then the result replaces the old value. In the trace earlier, x += 5 read 10, combined it with 5, and stored 15 back into x.

Operator overloading redefines operators for user-defined types. An overloaded operator is an ordinary function whose name is the keyword operator followed by the symbol. Built-in types such as integers and floating-point numbers already know what + and == mean. A complex number is different: it has a real part and an imaginary part, so a program that stores complex numbers in its own type needs a way to use ordinary operator symbols on them. Overloading lets an expression like a + b be carried out by a function written for that type.

The first definition in the source is the addition operator. Its name is operator+, it returns a complex value, and it takes two complex parameters called a and b. Its body is a single statement that returns a += b. The sketch below follows that pattern. It is an illustration written for this article, not the source's exact class listing; it assumes the class already defines the compound operator += as a member, as the pattern requires.

The source defines four binary arithmetic operators in the same pattern: addition, subtraction, multiplication, and division. Each takes two complex values, returns a complex value, and uses the matching compound assignment on the first parameter. Subtraction uses a -= b, multiplication uses a *= b, and division uses a /= b. Once a type has the compound assignment operators, each matching binary operator can be written in one line.

The source also defines a unary minus, which negates a single value. It uses the same symbol as binary subtraction, and this is the central point of the section. The compiler does not choose between the two forms by name, because both are named operator-. The difference is the parameter list: the binary form takes two complex parameters, and the unary form takes one.

Read the two columns side by side. Both use the same operator name, and neither refers to the other. A reader who sees only the symbol cannot tell which function runs. A reader who counts the parameters can. This is the core rule of overloading in this source: one operator symbol can have several definitions, and each definition is a different function selected by its signature.

The second group of definitions covers comparison. The equality operator returns a bool, and it is true only when both parts agree: the real parts are equal and the imaginary parts are equal. The source joins the two tests with the logical and operator, so both must succeed for the result to be true. The sketch below is an illustration in the same style as the source's description, not its exact listing.

When a result looks wrong, trace it through the definition one step at a time and note the exact expression where your expectation and the code part ways. Here the first comparison matches your intuition, and the second comparison is where the result is decided. Because operator!= is written in terms of operator==, a change to the meaning of equality changes not-equal too. Separate comparison code in each operator could drift apart and disagree.