C Assignment Operators

A program that never changes its variables can't do much. Bank balances go up and down, scores grow, timers count. C assignment operators are how you store and update those values. In this lesson, you'll learn the basic = operator, the handy shortcuts +=, -=, *=, /= and %=, and a few traps to avoid.

What is the assignment operator in C?

The assignment operator = stores the value on its right into the variable on its left. The old value is thrown away.

#include <stdio.h>

int main(void) {
    int score;

    score = 10;
    printf("Score: %d\n", score);

    score = 25;
    printf("Score: %d\n", score);

    return 0;
}

Score: 10
Score: 25

Read score = 10 as "score gets 10". The left side must be something that can hold a value, like a variable. The right side can be any expression: a number, another variable, or a whole calculation such as price * quantity.

Updating a variable using its own value

Often the new value depends on the old one. The right side is always calculated first, using the current value, and only then is the result stored:

int likes = 120;
likes = likes + 1;   /* read 120, add 1, store 121 */

This pattern is so common that C has a shorter way to write it.

What are compound assignment operators?

A compound assignment operator combines an arithmetic operator with =. Instead of repeating the variable name, you write the operator right before the equals sign:

Using += and -= (a bank balance)

#include <stdio.h>

int main(void) {
    int balance = 500;

    balance += 200;     /* deposit a paycheck */
    printf("After deposit:    %d\n", balance);

    balance -= 150;     /* pay the electricity bill */
    printf("After withdrawal: %d\n", balance);

    return 0;
}

After deposit:    700
After withdrawal: 550

+= is also the standard way to build a running total, such as adding each item's price to a cart total.

Using *=, /= and %= (a game score and a timer)

#include <stdio.h>

int main(void) {
    int score = 40;

    score *= 3;     /* triple-points power-up */
    printf("Power-up:  %d\n", score);

    score /= 2;     /* penalty: lose half your points */
    printf("Penalty:   %d\n", score);

    int seconds = 200;
    seconds %= 60;  /* seconds past the last full minute */
    printf("Seconds:   %d\n", seconds);

    return 0;
}

Power-up:  120
Penalty:   60
Seconds:   20

200 seconds is 3 full minutes and 20 seconds, so seconds %= 60 leaves 20.

/= follows the same division rules

Compound operators behave exactly like their long forms, including integer division:

#include <stdio.h>

int main(void) {
    int pages = 7;
    pages /= 2;

    double distance = 7.0;
    distance /= 2;

    printf("pages = %d\n", pages);
    printf("distance = %.1f\n", distance);

    return 0;
}

pages = 3
distance = 3.5

The right side is calculated first

With a compound operator, the whole right side is worked out before the operator is applied. x *= 2 + 3 means x = x * (2 + 3), not x = x * 2 + 3.

#include <stdio.h>

int main(void) {
    int price = 4;
    price *= 2 + 3;

    printf("%d\n", price);

    return 0;
}

20

Chained assignment: one value, many variables

You can assign the same value to several variables in one statement. Assignment works from right to left: draws = 0 happens first, its value (0) goes to losses, then to wins.

#include <stdio.h>

int main(void) {
    int wins, losses, draws;

    wins = losses = draws = 0;
    losses += 2;

    printf("W %d  L %d  D %d\n", wins, losses, draws);

    return 0;
}

W 0  L 2  D 0

This works because in C an assignment is itself an expression with a value: the value that was stored. You'll see how this "right to left" rule fits with other operators in the operator precedence lesson.

Why use compound assignment?

• Shorter and clearer: player_one_total_score += 10 is easier to read than repeating that long name.
• Fewer typos: you can't accidentally write score = scroe + 10 when the name appears only once.
• Shows intent: += tells the reader "this updates the value", not "this replaces it".

Common mistakes with assignment operators

1. Writing =+ instead of +=

#include <stdio.h>

int main(void) {
    int total = 10;
    total =+ 5;

    printf("%d\n", total);

    return 0;
}

5

C reads total =+ 5 as total = +5: a plain assignment of positive 5. The program compiles without complaint and silently loses the 10. The operator symbol always comes before the equals sign.

2. Updating a variable that has no starting value

int sum;
sum += 10;   /* sum had no value yet */

sum was never initialized, so it holds a leftover garbage value from memory, and adding 10 to garbage gives garbage. This is undefined behavior. Always start totals at a known value: int sum = 0;.

3. Putting a value on the left side

10 = count;   /* error */

GCC reports error: lvalue required as left operand of assignment. An lvalue is something that has a place in memory, like a variable. A plain number has nowhere to store anything.

4. Using = when you mean ==

= stores a value; == compares two values. Mixing them up is one of the most famous bugs in C. You'll learn all about it in the next lesson.

Practice exercise

#include <stdio.h>

int main(void) {
    int savings = 0;

    savings += 250;
    savings += 250;
    savings += 250;
    savings -= 120;

    printf("Savings: $%d.%02d\n", savings / 100, savings % 100);

    return 0;
}

Savings: $6.30

What's next?

You can store and update values. Next, learn how to compare them with ==, <, > and friends in C comparison operators.