Assignment and compound assignment

Understanding Assignment and compound assignment

Assignment in C++ is an operator, not a statement: `x = 7` is an expression whose value is `x` itself, as a modifiable lvalue. That is why `a = b = c = 10;` works. `=` groups right to left, so `c = 10` runs first, the result is the freshly updated `c`, and that value flows left into `b` and then `a`. The `=` in `int x = 5;` is a different thing entirely: it is initialization syntax, so the variable is built holding 5 rather than being handed a value it already had. For class types that distinction decides whether a constructor runs or an assignment operator runs, and only the assignment operator has to deal with an existing value it must discard.

Compound assignment `x op= y` means `x = x op y` with two deliberate differences. First, the left operand is evaluated exactly once, so `counts[hash(key)] += 1` computes that subscript once where the long form computes it twice, which matters as soon as the subexpression calls a function or walks a pointer. Second, the arithmetic happens after the usual arithmetic conversions and the result is then converted back to the type of the left operand, even when that loses information: `int m = 5; m /= 2.0;` computes 2.5 as a `double` and stores 2. The truncation is part of what `/=` means there, not a stray bug, which is why adding a fractional amount into an `int` counter can move it by nothing at all.

For class types none of this is built in; `operator+=` and `operator=` are functions someone wrote. The convention is that `+=` mutates the object in place while `a + b` builds a new object that then has to be assigned, so `s += "local"` appends into the buffer the string already owns while `s = s + "local"` constructs a temporary, moves it in, and destroys it. That is why the compound form is the default for strings and any other type whose copies cost something. C++ also has no `&&=` or `||=`: the set is `+= -= *= /= %= &= |= ^= <<= >>=`, and a `&&=` is absent because it would have to skip evaluating its right operand sometimes, which is not how the other compound operators behave.

#include <iostream>
#include <string>

int main() {
    int a = 0, b = 0, c = 0;   // the = here is initialization, not assignment
    a = b = c = 10;            // right to left: c = 10, then b = c, then a = b
    std::cout << a << ' ' << b << ' ' << c << '\n';

    int n = 7;
    n += 3;                    // 10
    n *= 2;                    // 20
    n /= 3;                    // still integer division: 6
    std::cout << "n = " << n << '\n';

    int m = 5;
    m /= 2.0;                  // 5 / 2.0 is 2.5, converted back to int
    std::cout << "m = " << m << '\n';

    std::string s = "log";
    s += ':';
    s += " ready";
    std::cout << s << '\n';

    int k = 4;
    int r = (k += 6);          // the whole expression yields k after the update
    std::cout << "r = " << r << ", k = " << k << '\n';
}

Worked examples

#include <iostream>

int calls = 0;

int slot() {
    ++calls;
    return 1;
}

int main() {
    int data[3] = {0, 0, 0};

    data[slot()] += 5;
    std::cout << "compound: calls = " << calls << ", data[1] = " << data[1] << '\n';

    calls = 0;
    data[slot()] = data[slot()] + 5;
    std::cout << "long    : calls = " << calls << ", data[1] = " << data[1] << '\n';
}

#include <iostream>

int main() {
    int score = 9;
    score += 0.9;
    std::cout << "score = " << score << '\n';

    double avg = 7;
    avg /= 2;
    std::cout << "avg   = " << avg << '\n';

    unsigned char level = 250;
    level += 10;
    std::cout << "level = " << static_cast<int>(level) << '\n';
}

#include <iostream>
#include <string>

int main() {
    std::string path = "usr";
    path += '/';
    path += "local";
    std::cout << path << '\n';

    std::string other = path;
    other = "elsewhere";
    std::cout << path << " | " << other << '\n';
}

Important notes

Common mistakes

Try it yourself