Assignment Operators in C: Basic and Compound Assignment

The Basic Assignment Operator (=)

The=operator takes the value on therightand stores it in the variable on theleft:

int marks;
// declare the box
marks = 85;
// put 85 into it

Two rules govern everything:

1. Flow is right → left.The right side is calculated first; the result lands in the left side.
2. The left side must be a container.Only something that canholda value (a variable, an array slot, a dereferenced pointer) can sit left of=. Programmers call this anlvalue— "left value."

int x = 10;
x = 20;
// ✅ x is a container
x + 5 = 20;
// ❌ ERROR — x + 5 is a calculation, not a box
10 = x;
// ❌ ERROR — you can't store into a literal

That second rule is why10 = xfails: a number literal has no memory slot to fill. The lvalue rule is the compiler's way of asking,"Where exactly should I put this?"

Assignment Is an Expression (The Sneaky Detail)

Here's what most tutorials skip:an assignment itself has a value— the value that was assigned. That's why chained assignment works:

int a, b, c;
a = b = c = 42;
// legal! works right to left

C reads it asa = (b = (c = 42)):cbecomes 42 (and thatexpressionis 42), sobbecomes 42, thena. All three end up holding 42. This also explains whyif (x = 5)compiles — the assignment evaluates to 5, which is non-zero, which is true. The classic bug, explained by one rule.

The Compound Assignment Operators: C's Shorthand

Watch the pattern in everyday code:

score = score + 50;
// read score, add 50, store back
balance = balance - fee;
total = total * count;

"Take the variable, operate on it, store it back" is so common that C built dedicated shortcuts —compound assignment operators:

#include <stdio.h>
int main() {
    int score = 100;
    score += 50;
    // 150 — collect bonus
    score -= 30;
    // 120 — pay penalty
    score *= 2;
    // 240 — double or nothing!
    score /= 3;
    // 80  — integer division (watch the trap!)
    score %= 7;
    // 3   — remainder of 80 / 7
    printf("Final score: %d\n", score);
    // 3
    return 0;
}

Same arithmetic rules apply underneath —/=on integers still truncates,%=still returns the remainder. Compound operators change thesyntax, not the math.

Why Compound Operators Are Worth Using

Three honest reasons professionals preferx += 5overx = x + 5:

1. Less repetition.The variable appears once — less typing, and no chance ofscore = scor + 5typos that compile into brand-new bugs.

2. Clearer intent.count += 1instantly reads as "increment this thing" — the reader doesn't have to verify both sides mention the same variable.

3. It really matters with long expressions:

studentRecords[classId][studentId].marks += bonusPoints;
// vs repeating that whole left side twice — imagine the typo risk

When the left side is complicated, compound assignment isn't just style — it's safety.

The Traps: = vs ==, Chaining, and Division

Trap 1: Assignment Is Not Comparison

From this side of the fence, the famous bug looks like this: youmeantto compare, but typed assign:

int lives = 3;
if (lives = 0) {
    // 😱 assigns 0 — and 0 is FALSE
    printf("Game over!\n");
    // never runs — backwards from intent!
}
// lives is now 0 — silently destroyed

if (lives = 0)assigns zero, evaluates to zero, and the block never runs. Two bugs in five characters. The fix remains eternal vigilance (or the Yoda habitif (0 == lives)):comparison needs==, full stop.

Trap 2: Compound Division Still Truncates

int average = 95;
average /= 4;
// 23 — NOT 23.75! Integer division applies here too

/=inherits all of/'s integer behavior. For decimal results, the variable itself must be a floating type:

double average = 95;
average /= 4;
// 23.75 ✅

Trap 3: Modulus Compound Needs Integers

Just like%, the%=operator refuses floating-point operands:

double d = 10.5;
// d %= 3;
// ❌ ERROR — modulus is integers-only

A Complete Working Example: Bank Account Simulator

#include <stdio.h>
int main() {
    double balance = 1000.0;
    printf("Opening balance: %.2f\n", balance);
    balance += 500;
    // salary credited
    printf("After deposit:  %.2f\n", balance);
    balance -= 199.99;
    // online shopping
    printf("After shopping: %.2f\n", balance);
    balance *= 1.02;
    // 2% interest
    printf("After interest: %.2f\n", balance);
    int wholeRupees =(int) balance;
    wholeRupees %= 100;
    // last two digits, just because we can
    printf("Last two digits: %d\n", wholeRupees);
    return 0;
}

Output:

Opening balance: 1000.00
After deposit: 1500.00
After shopping: 1300.01
After interest: 1326.01
Last two digits: 26

Four compound operators doing everyday work — deposit, spend, grow, extract — in a program that reads almost like the bank statement it describes.