Assignment Statements

Imagine a program tracking how many goals a team has scored. Each time a goal goes in, the stored count has to rise by one. Programs handle this kind of change with assignment statements, the basic mechanism for storing values in variables. In this article you will follow that mechanism step by step, from a statement that stores a computed result to the timing rules of the increment and decrement operators, which cause many bugs when they appear inside larger expressions.

The general form is variable = expression; The left side names the destination that receives the value. The right side is the expression, which describes the computation that produces the value. In an assignment, the variable is the part receiving the value, and the expression is the part being computed.

This statement uses the value already held in principal, multiplies it by 0.07, and stores the result in interest. The assignment therefore combines two actions: computing with existing data and storing the result of that computation. Assignment statements connect computation with storage.

Read the diagram from left to right. The computation happens in the middle, and only at the end does a value land in the variable on the far right. When you trace any assignment, follow the same path: first find what the expression computes, then find the variable that receives it.

The increment operator ++ increases a variable by 1, and the decrement operator -- decreases a variable by 1. Whatever form you use, the operator always changes the variable by 1. The question that matters is which value the surrounding expression produces, and that is covered in the next section.

A common mistake is to treat x++ as if it were simply x + 1. They are not the same. The expression x + 1 computes a value but does not change x. The expression x++ changes x by adding 1, and it also produces a value that can be used in a larger expression. This difference is the source of many bugs.

The decrement forms follow the same pattern. The rule you learn for ++ carries over to --, so once you understand the timing for x++ you can apply the same reasoning to x--.

The position of ++ determines which value the expression produces. This is the central idea of this article. The operator does its change to the variable either way, but the value handed to the rest of the expression depends on where the operator sits.

With post-increment, written x++, the old value of x is produced first, and then x is increased by 1. The diagram shows that order: the value 5 is produced and reaches y before x becomes 6.

With pre-increment, written ++x, x is increased by 1 first, and the new value is produced. So the same starting value of 5 gives a different result for y in that case, because the increase happens before the value is read.

The same timing applies to decrement. In y = x--, y receives the old value of x, and then x is reduced by 1. In y = --x, x is reduced by 1 first, and y receives the new value.

The statement x = x++ looks as if it should increase x, but it does not change the final value of x. The reason follows from the timing rules above. The post-increment first produces the old value of x, which is used for the assignment. Although x is incremented during the operation, the assignment then stores that old value back into x. The final value of x is therefore unchanged.

The state diagram follows x through the statement. x begins at 5, rises to 6 during the increment, and then receives the old value 5 from the assignment. The temporary rise to 6 is real, but it does not survive the statement.

Increment and decrement operators are easiest to understand when they are used as standalone statements. A statement such as counter++ clearly commands the program to increase counter, and goalsScored++ clearly increases goalsScored. Here the operator is used for its change to the variable, not for a value inside a larger expression.