Increment and decrement operators

In C++, the increment (++) and decrement (--) operators are essential arithmetic operators that allow you to increase or decrease the value of a variable by one. These operators come in two forms: prefix and postfix, each with its own behavior and side effects. In this topic, you will explore the increment and decrement operators, their different forms, and best practices associated with their usage.

Increment (++) & decrement (--) operators

Use the increment (++) and decrement (--) operators to modify a variable's value by adding or subtracting one, respectively. They are unary operators, meaning they operate on a single operand (a variable, or any other entity that participates in an operation). Here is the basic syntax for these operators:

++someVariable; // Prefix increment
--someVariable; // Prefix decrement

someVariable++; // Postfix increment
someVariable--; // Postfix decrement

In the postfix form, the operator appears after the variable, while in the prefix form, it appears before the variable. The difference in placement affects the behavior of these operators and how they interact with the rest of the expression. You'll take a look at their behavior in the below sections.

Prefix form: write the prefix form of the increment and decrement operators before the variable, like ++someVariable or --someVariable. When you use the prefix form, the variable's value modifies first, and then the expression uses the updated value. Here's an example:

int number = 10;
int addFive;

std:: cout << "Number before: " << number << std::endl;
int result = ++number; // Increment 'number' first, then use its value

std::cout << "Number after: " << number << std::endl; // the value of 'number' increased by 1
std::cout << "Result: " << result << std::endl; // the value of 'result' is 11 i.e. modified value

addFive = number + 5; // updated value of 'number' i.e. 11 is being used here
std::cout << "Sum: " << addFive << std::endl;

// Now, 'number' is 11, and 'result' is also 11

Here is the output of the above code snippet,

Number before: 10
Number after: 11
Result: 11
Sum: 16

Postfix form: write the postfix form of the increment and decrement operators after the variable, like someVariable++ or someVariable--. When you use the postfix form, the expression uses the variable's value first and then modifies the variable. Here's an example:

int number = 10;
int addFive;

std:: cout << "Number before: " << number << std::endl;
int result = number++; // Use the value of 'number' first, and then increment it.

std::cout << "Number after: " << number << std::endl; // the value of 'number' increased by 1
std::cout << "Result: " << result << std::endl;

addFive = number + 5; // updated value of 'number' i.e. 11 is being used here
std::cout << "Sum: " << addFive << std::endl;

// Now, 'number' is 11, and 'result' is still 10

Here is the output of the above code snippet,

Number before: 10
Number after: 11
Result: 10
Sum: 16

Here is a nice table that explains the increment and decrement operators.

Side effects

Using increment (++) and decrement (--) operators in C++ can have side effects that programmers should be aware of. These side effects can lead to unexpected behavior or bugs in your code if not used carefully. Let's discuss some of the common side effects below:

1. Confusion with postfix form: The postfix form of the increment and decrement operators can cause confusion in more complex expressions. Consider the below example:

int firstNum = 5;
int secondNum = 2 * firstNum++; // Is 'secondNum' equal to 10 or 12?

The value of y depends on whether the postfix (here, firstNum++ ) takes effect before or after the multiplication. To avoid confusion, you should use the prefix form or separate the increment and usage in expressions.

Rewritten example with prefix form:

int firstNum = 10;
int secondNum = 2 * ++firstNum; // 'secondNum' is always 22 (2 * 11)

Here, the value of secondNum will always be 22 (2 * 11). This is because the prefix form increments firstNum first and then uses the updated value (11) in the multiplication, ensuring consistent and predictable behavior.

2. Unintended modifications: Using the increment and decrement operators can lead to unintentional modifications of the original variable. This is particularly an issue when using the postfix form. Let's take a look at an example below:

int firstNum = 10;
int result = firstNum++; // 'firstNum' is now 11, but 'result' is 10

In this case, if you intended to use the original value of firstNum in multiple places, using the postfix form may lead to bugs.

Rewritten example with prefix form:

int firstNum = 10;
int result = ++firstNum; // 'firstNum' is now 11, and 'result' is also 11

Here, you increment the variable firstNum first, and then assign the updated value to both firstNum and result. This ensures that both firstNum and result hold the same value, preventing any unintended modification of the original variable.

3. Undefined Behavior with Multiple Updates in One Expression: Using the increment or decrement operators multiple times within the same expression on the same variable can lead to undefined behavior; let's take a look at an example below:

#include <iostream>

int main()
{
    int firstNum = 10;

    //  Undefined behavior - Don't modify the same variable multiple times within one expression.
    int secondNum = firstNum++ + firstNum++; 

    std::cout << firstNum << std::endl;
    std::cout << secondNum << std::endl;
    std::cout << firstNum << std::endl;

    return 0;
}

In this case, the result is undefined because the order of evaluation of sub-expressions is not guaranteed. The C++ standard does not specify whether the first firstNum++ or the second firstNum++ is evaluated first. Here, the value of firstNum was modified twice within the same expression without any sequence point. The result of such an operation was unpredictable due to the unspecified order of evaluation.

Rewritten example with prefix form:

#include <iostream>

int main()
{
    int firstNum = 10;

    //  May be an undefined behavior (result depends on compiler)
    int secondNum = ++firstNum + ++firstNum; 

    std::cout << firstNum << std::endl;
    std::cout << secondNum << std::endl;
    std::cout << firstNum << std::endl;

    return 0;
}

In this example, you use the prefix form (++firstNum) for both increments. When using the prefix form, increment the value of firstNum first, and then use the updated value in the expression.

The first firstNum is incremented from 10 to 11, and this updated value 11 is used in the expression. And, the second firstNum is incremented from 11 to 12, and this updated value 12 is used in the expression again. Thus, the expression becomes 11 + 12, resulting in secondNum being assigned the value 23. But you'll notice differences in the outputs when different compilers are used to compile the above program. This is because even the C++ standard does make it clear how things should be evaluated. And, historically this particular scenario has been an area where there have been many compiler bugs.

Best practices

1. Prefer Prefix Increment/Decrement: It is generally recommended to use the prefix form (++someVariable, --someVariable) over the postfix form (someVariable++, someVariable--) unless the postfix behavior is explicitly required. The prefix form is often more efficient, as it avoids unnecessary overhead associated with creating a temporary copy of the variable.

#include <iostream>

int main() {
    int firstNum = 10;
    int secondNum = ++firstNum * 2;

    std::cout << "firstNum: " << firstNum << ", secondNum: " << secondNum << "\n";
    
    firstNum = 10;
    secondNum = firstNum++ * 2;

    std::cout << "firstNum: " << firstNum << ", secondNum: " << secondNum << "\n";

    return 0;
}

In this example, you see the difference between prefix and postfix increments when combined with other operators. The first case uses prefix increment, so the value of firstNum is first incremented to 11 and then multiplied by 2, resulting in secondNum being 22. In the second case, postfix increment is used, so the original value of firstNum (10) is used to compute secondNum, and then firstNum is incremented to 11. Therefore, secondNum is 20, not 22, as some might expect. Hence, use prefix increment/decrement to avoid confusion and undefined behaviors.

2. Avoid Mixing Increment/Decrement with Other Operators: To avoid confusion and ensure predictable results, it's best to use increment and decrement operators separately or in isolation. Mixing them with other operators in the same expression can lead to unexpected behavior, especially when using the postfix form.

Conclusion

Understanding the increment and decrement operators in C++ is crucial for every beginner. These operators allow you to modify the value of variables conveniently. However, their side effects and differences between the prefix and postfix forms can lead to unintended consequences if not used properly. By following best practices and favoring the prefix form, you can write more efficient and predictable code.