Operators and Expressions

#include <stdio.h>

int main(void)
{
    int a = 17, b = 5;

    printf("%d %d %d %d %d\n", a + b, a - b, a * b, a / b, a % b);   // 22 12 85 3 2
    printf("%+d %d\n", +a, -a);                                       // unary plus and minus

    double x = 17.0, y = 5.0;
    printf("%g %g\n", x / y, 17.0 / 5);        // 3.4 3.4 -- one double operand is enough
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a, b;
    a = b = 0;                  // right-associative: a = (b = 0)

    a += 5;  a -= 2;  a *= 4;  a /= 3;  a %= 5;
    a <<= 2; a >>= 1; a &= 0xFF; a |= 0x10; a ^= 0x01;

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

#include <stdio.h>

int main(void)
{
    int i = 5;

    printf("%d ", i++);     // 5 -- yields the old value, then increments
    printf("%d\n", i);      // 6
    printf("%d ", ++i);     // 7 -- increments, then yields the new value
    printf("%d\n", i);      // 7

    int arr[4] = { 10, 20, 30, 40 };
    int *p = arr;
    int first = *p++;                   // ++ binds tighter than *: read *p, then advance p
    printf("%d %d\n", first, *p);       // 10 20

    // Note the two statements: writing printf("%d %d\n", *p++, *p) instead would be
    // undefined behavior -- an unsequenced modification and access of the same object.
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 3, b = 7;

    printf("%d %d %d %d %d %d\n", a == b, a != b, a < b, a <= b, a > b, a >= b);

    // Logical operators short-circuit: the right operand is not evaluated if
    // the result is already known. There is a sequence point between them.
    int *maybe_null = nullptr;
    if (maybe_null != nullptr && *maybe_null > 0) {      // safe: deref never happens
        puts("positive");
    }

    printf("%d %d %d\n", a && b, a || b, !a);            // results are 0 or 1, type int
    return 0;
}

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint8_t flags = 0b0000'1100;

    uint8_t set     = (uint8_t)(flags | 0b0000'0001);    // set a bit
    uint8_t cleared = (uint8_t)(flags & (uint8_t)~0b0000'0100);   // clear a bit
    uint8_t toggled = (uint8_t)(flags ^ 0b0000'1000);    // toggle a bit
    bool    tested  = (flags & 0b0000'0100) != 0;        // test a bit

    unsigned value = 1u;
    unsigned left  = value << 4;        // 16
    unsigned right = 256u >> 4;         // 16

    printf("%u %u %u %d %u %u\n", set, cleared, toggled, (int)tested, left, right);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 3, b = 7;

    int max = a > b ? a : b;                    // the only ternary operator in C
    const char *label = max > 5 ? "big" : "small";

    // Exactly one of the two branches is evaluated -- there is a sequence point
    // after the condition, so this is safe even with side effects:
    int i = 0;
    int chosen = (a > b) ? i++ : --i;

    printf("%d %s %d %d\n", max, label, chosen, i);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0, b = 0;

    // Evaluates the left operand, discards it, then yields the right one --
    // with a sequence point in between. Legitimate mainly in for-loop clauses:
    for (a = 0, b = 10; a < b; ++a, --b) {
        /* converge */
    }

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

#include <stdalign.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    double d = 3.99;
    int truncated = (int)d;                 // explicit conversion
    void *raw = malloc(4 * sizeof(int));
    int *numbers = raw;                     // void * converts implicitly -- no cast needed in C

    if (numbers == nullptr) {
        return EXIT_FAILURE;
    }
    numbers[0] = truncated;

    printf("%d %zu %zu %zu\n", numbers[0], sizeof d, sizeof(int), alignof(double));
    free(numbers);
    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned flags = 0x0Cu;

    // if (flags & 0x04 == 0x04)     // WRONG: parses as flags & (0x04 == 0x04) == flags & 1
    if ((flags & 0x04u) == 0x04u) {  // right
        puts("bit set");
    }

    int a = 1, b = 2, c = 3;
    printf("%d %d\n", a + b * c, (a + b) * c);      // 7 9 -- * binds tighter
    printf("%d\n", 1 << (2 + 3));                   // 32: + binds tighter than <<, so an
                                                    // unparenthesized 1 << 2 + 3 means this
                                                    // (and Clang warns: -Wshift-op-parentheses)
    printf("%d\n", (1 << 2) + 3);                   // 7 -- what it usually looks like it means
    return 0;
}

#include <stdio.h>

struct Point { int x, y; };

int main(void)
{
    int i = 1;
    int arr[3] = { 1, 2, 3 };
    struct Point p = { 1, 2 };
    int *q = &i;

    i = 5;              // lvalue
    arr[1] = 5;         // lvalue
    p.x = 5;            // lvalue
    *q = 5;             // lvalue

    // 42 = i;          // error: 42 is not an lvalue
    // (i + 1) = 5;     // error: the result of + is not an lvalue

    const int ci = 1;
    // ci = 2;          // error: a const-qualified lvalue is not modifiable

    printf("%d %d %d %d\n", i, arr[1], p.x, ci);
    return 0;
}

#include <stdio.h>

static int next_id(void)
{
    static int id = 0;
    return ++id;
}

int main(void)
{
    // UNDEFINED -- two unsequenced modifications of i:
    //   int i = 0; i = i++ + 1;
    //   int a[2] = {0}; int j = 0; a[j] = j++;

    // UNSPECIFIED but not undefined -- argument evaluation order is up to the compiler,
    // so this may print "1 2" or "2 1":
    printf("%d %d\n", next_id(), next_id());

    // Sequenced, and therefore safe: &&, ||, ?: and , each impose an order.
    int x = 0;
    int ok = (x = 1) && (x == 1);
    printf("%d %d\n", x, ok);
    return 0;
}