Assignment Shortcuts, ++ and --

David has a counter and wants the next value. He writes i = i++;, because it reads like "i becomes i, increased".

The Playground compiles it without a word. On his machine it leaves i unchanged. A friend runs the same file and gets a different answer.

Neither machine is broken. That line asks C to do two things to one box in one step, and the standard refuses to say which one wins.

Five shortcuts for changing a variable you already have

Adding to a running total is so common that C has a shorter spelling for it.

total += x      the same as   total = total + x
total -= x      the same as   total = total - x
total *= x      the same as   total = total * x
total /= x      the same as   total = total / x
total %= x      the same as   total = total % x

#include <stdio.h>

int main(void)
{
    int total = 100;

    total += 25;
    printf("after +=  %d\n", total);
    total -= 5;
    printf("after -=  %d\n", total);
    total *= 2;
    printf("after *=  %d\n", total);
    total /= 7;
    printf("after /=  %d\n", total);
    total %= 10;
    printf("after %%=  %d\n", total);
    return 0;
}

after +=  125
after -=  120
after *=  240
after /=  34
after %=  4

Line four is the one to watch. 240 divided by 7 is 34.28, and total is an int, so the answer is 34.

So /= carries lesson 1's integer division with it. The shortcut changed the spelling, not the arithmetic.

The conversion that hides inside the shortcut

total *= 1.5 is not exactly total = total * 1.5. It is total = (int)(total * 1.5), with the cast written in for you.

That last step is silent. It is the reason the two forms are not identical, and the reason a price can quietly lose its fraction.

#include <stdio.h>

int main(void)
{
    int price = 7;

    price *= 1.5;

    printf("%d\n", price);
    return 0;
}

10

Seven times 1.5 is 10.5. The multiplication really did happen in double, and then 10.5 was cut down to fit an int.

Nothing is said about it at either command line, and not even under -Wall -Wextra. A local gcc -Wconversion reports warning: conversion from 'double' to 'int' may change value.

So a compound assignment always lands back in the left variable's type. Lesson 6 gives that conversion its proper name.

++ and --, and the value each form hands back

n++ and ++n both add 1 to n. They differ in what the expression is worth while they do it.

n++ is the postfix form. Its value is the old n. ++n is the prefix form, and its value is the new one.

#include <stdio.h>

int main(void)
{
    int n = 5;
    printf("n++ gives %d\n", n++);
    printf("n is now  %d\n", n);

    int m = 5;
    printf("++m gives %d\n", ++m);
    printf("m is now  %d\n", m);
    return 0;
}

n++ gives 5
n is now  6
++m gives 6
m is now  6

Both variables end at 6. The only difference is the number that reached printf.

So the choice matters exactly when you use the value. On a statement of its own, the two forms are the same.

Two changes to one box, in one expression, is undefined

Between two statements, C guarantees everything is finished. Inside one expression, it guarantees far less.

The rule for this track, stated plainly: if one expression changes a variable and also reads or changes it again, the behaviour is undefined. Not unspecified, not compiler-dependent: undefined.

That is what i = i++ does. It assigns to i and increments i, and nothing orders those two events.

Undefined means the standard places no requirement on the program at all. No output of such a line is quoted anywhere in this track, because there is no correct output to quote.

int i = 3;
i = i++;

The Playground says nothing about this, because the check lives behind -Wall. A local gcc -Wall reports warning: operation on 'i' may be undefined, and the word "may" is the compiler being honest about how hard this is to detect.

The rule this track follows

The rule is short: write ++ and -- on a line of their own, never inside a larger expression.

You give up nothing. Every use has a two-line version that says the same thing and is always defined.

#include <stdio.h>

int main(void)
{
    int i = 3;
    int copy = i;
    i++;

    printf("copy %d, i %d\n", copy, i);
    return 0;
}

copy 3, i 4

Two statements, two ordered steps, one obvious reading. Module 6 puts i++ in the one place the language reserves for it, the third slot of a for header.

So the shortcut is welcome; hiding it inside another expression is not.

#include <stdio.h>

int main(void)
{
    int total = 0;

    total += 10;
    total += 20;
    total += 30;

    printf("%d\n", total);
    return 0;
}

60

#include <stdio.h>

int main(void)
{
    int next_ticket = 41;

    int mine = next_ticket++;
    int yours = next_ticket++;

    printf("mine  %d\n", mine);
    printf("yours %d\n", yours);
    printf("next  %d\n", next_ticket);
    return 0;
}

mine  41
yours 42
next  43

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    scanf("%d %d %d %d", &a, &b, &c, &d);

    int total = 0;
    int count = 0;

    total += a;
    count++;
    total += b;
    count++;
    total += c;
    count++;
    total += d;
    count++;

    printf("total %d over %d marks\n", total, count);
    printf("average %.2f\n", total / (double)count);
    return 0;
}

total 329 over 4 marks
average 82.25

int i = 3;
i = i++;

int total = 100;
total =+ 25;
printf("%d\n", total);

int total = 7;
total /= 2;
printf("%d\n", total);

int n = 5;
printf("%d\n", n++);

int x = 3;
int y = x++ + ++x;
printf("%d %d\n", x, y);

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    int e = 0;
    scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);

    int total = 0;
    /* Five += lines, one per value. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Four printf lines. Each one touches n at most once. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Four steps, four printf lines, all on the same box. */

    return 0;
}

Next you leave whole numbers behind and work on the bits inside them, one at a time.