← Operators & Expressions

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

How do the / and % operators work with integers in C?

Integer division (/) truncates toward zero in C99+. The fractional part is discarded.

Modulo (%) returns the remainder after integer division. The sign of the result follows the dividend (numerator) in C99+.

Key rules (C99/C11):

(a/b)*b + a%b == a always holds.
Truncation toward zero: 7/2 == 3, -7/2 == -3.
Modulo sign follows dividend: 7%2 == 1, -7%2 == -1, 7%-2 == 1.
Division by zero is undefined behavior (not just a runtime error -- the compiler can assume it never happens).

Pre-C99: The direction of truncation for negative operands was implementation-defined. C99 standardized truncation toward zero.

Pseudo Code

1. Integer division truncates toward zero: 7/2 = 3, -7/2 = -3
2. Modulo: (a/b)*b + a%b == a (always holds)
3. Modulo sign follows the dividend: -7%2 = -1
4. Division by zero is undefined behavior
5. Both operands must be integers for %

Code

#include <stdio.h>

int main(void) {
    /* Integer division truncates toward zero */
    printf(" 7 / 2  = %d\n",  7 / 2);   /*  3 */
    printf("-7 / 2  = %d\n", -7 / 2);   /* -3 (toward zero, not -4) */
    printf(" 7 / -2 = %d\n",  7 / -2);   /* -3 */
    printf("-7 / -2 = %d\n", -7 / -2);   /*  3 */

    /* Modulo: sign follows dividend */
    printf(" 7 %% 2  = %d\n",  7 % 2);   /*  1 */
    printf("-7 %% 2  = %d\n", -7 % 2);   /* -1 */
    printf(" 7 %% -2 = %d\n",  7 % -2);  /*  1 */
    printf("-7 %% -2 = %d\n", -7 % -2);  /* -1 */

    /* Verify: (a/b)*b + a%b == a */
    int a = -7, b = 2;
    printf("(%d/%d)*%d + %d%%%d = %d + %d = %d\n",
           a, b, b, a, b, (a/b)*b, a%b, (a/b)*b + a%b); /* -7 */

    /* % only works with integers */
    /* printf("%f", 7.5 % 2.0); // ERROR: invalid operands to % */
    /* Use fmod() for floating-point remainder */

    return 0;
}

 7 / 2  = 3
-7 / 2  = -3
 7 / -2 = -3
-7 / -2 = 3
 7 % 2  = 1
-7 % 2  = -1
 7 % -2 = 1
-7 % -2 = -1
(-7/2)*2 + -7%2 = -6 + -1 = -7

Key Points

•Integer division truncates toward zero (C99+)
•Modulo sign follows the dividend (numerator)
•(a/b)*b + a%b == a always holds
•% operator only works on integer types
•Use fmod() from <math.h> for floating-point remainder

Gotchas

•Division by zero is undefined behavior, not just a crash -- the compiler can assume it never happens
•INT_MIN / -1 is undefined behavior on two's complement systems (result overflows)
•Pre-C99, truncation direction for negative numbers was implementation-defined
•-7 % 2 is -1 in C99+ but could be 1 in older compilers

Integer division truncates toward zero: -7/2 == -3. Modulo sign follows the dividend: -7%2 == -1. Division by zero is UB. % only works on integers; use fmod() for floats.

•Truncation toward zero; modulo sign follows dividend
•Division by zero is undefined behavior

#include <stdio.h>
int main(void) {
    printf("-7/2 = %d\n", -7/2);   /* -3 */
    printf("-7%%2 = %d\n", -7%2);  /* -1 */
    return 0;
}

-7/2 = -3
-7%2 = -1

INT_MIN / -1 overflows and is undefined behavior

Question 2 / 12

How does short-circuit evaluation work with logical operators?

Short-circuit evaluation means the second operand is NOT evaluated if the first operand determines the result.

&& (logical AND):

If the left operand is 0 (false), the right operand is NOT evaluated (result is guaranteed 0).

|| (logical OR):

If the left operand is non-zero (true), the right operand is NOT evaluated (result is guaranteed 1).

Why it matters:

Safety: if (ptr != NULL && ptr->value > 0) -- the dereference only happens if ptr is not NULL.
Performance: Expensive checks can be placed second.
Side effects: If the second operand has side effects (like i++), they may or may not execute.

Key distinction:

&& and || short-circuit (left-to-right, with a sequence point).
& and | (bitwise) do NOT short-circuit -- both sides are always evaluated.

Pseudo Code

1. a && b: if a is false, b is NOT evaluated, result is 0
2. a || b: if a is true, b is NOT evaluated, result is 1
3. Short-circuit creates a sequence point between operands
4. Bitwise & and | do NOT short-circuit
5. Use for null pointer checks: ptr && ptr->field

Code

#include <stdio.h>

int check(int x) {
    printf("  check(%d) called\n", x);
    return x;
}

int main(void) {
    printf("AND short-circuit:\n");
    if (check(0) && check(1)) { /* check(1) never called */ }
    /* Output: check(0) called */

    printf("OR short-circuit:\n");
    if (check(1) || check(0)) { /* check(0) never called */ }
    /* Output: check(1) called */

    printf("No short-circuit:\n");
    if (check(1) && check(1)) { /* both called */ }
    /* Output: check(1) called, check(1) called */

    /* Practical: safe null check */
    int *ptr = NULL;
    if (ptr != NULL && *ptr > 0) {
        printf("value = %d\n", *ptr);
    } else {
        printf("ptr is NULL (safe!)\n");
    }

    /* Side effect gotcha */
    int i = 0;
    if (0 && (i = 42)) { /* i = 42 is NOT executed */ }
    printf("i = %d\n", i); /* 0, not 42 */

    return 0;
}

AND short-circuit:
  check(0) called
OR short-circuit:
  check(1) called
No short-circuit:
  check(1) called
  check(1) called
ptr is NULL (safe!)
i = 0

Key Points

•&& stops if left is false; || stops if left is true
•Short-circuit introduces a sequence point between operands
•Essential for safe null pointer checks: ptr && ptr->field
•Bitwise & and | do NOT short-circuit
•Result of && and || is always 0 or 1

Gotchas

•Side effects in the second operand may not execute: 0 && (x = 5) does NOT set x
•Do not confuse && with & -- they have different evaluation rules
•Short-circuit can hide bugs: if the second condition has important side effects
•The result of && and || is int (0 or 1), not the operand value (unlike Python/JS)

&& stops if left is false (0). || stops if left is true (non-zero). The right operand is skipped entirely. Use for safe null checks: ptr && ptr->field. Bitwise &/| do NOT short-circuit.

•&& short-circuits on false; || on true
•Bitwise & and | always evaluate both sides

#include <stdio.h>
int main(void) {
    int *p = NULL;
    if (p != NULL && *p > 0) { /* safe: *p not evaluated */ }
    int x = 0;
    0 && (x = 5); /* x stays 0 */
    printf("%d\n", x); /* 0 */
    return 0;
}

Side effects in the skipped operand do NOT execute

Question 3 / 12

How do bitwise operators work in C (&, |, ^, ~, <<, >>)?

Bitwise operators work on individual bits of integer values:

& (AND): Both bits must be 1 -> 1. Used for masking (extracting specific bits). | (OR): Either bit is 1 -> 1. Used for setting bits. ^ (XOR): Bits differ -> 1. Used for toggling bits, swap without temp. ~ (NOT): Flips all bits (one's complement). << (left shift): Shifts bits left, fills with 0. Equivalent to multiplying by 2^n. >> (right shift): Shifts bits right. For unsigned: fills with 0. For signed: implementation-defined (usually arithmetic shift, fills with sign bit).

Bitwise operators only work on integer types (char, short, int, long, etc.), not floating-point.

Pseudo Code

& (AND):  1010 & 1100 = 1000  (mask bits)
| (OR):   1010 | 1100 = 1110  (set bits)
^ (XOR):  1010 ^ 1100 = 0110  (toggle bits)
~ (NOT):  ~1010 = 0101         (flip all bits)
<< (LSH): 0001 << 2 = 0100    (multiply by 2^n)
>> (RSH): 1000 >> 2 = 0010    (divide by 2^n)

Code

#include <stdio.h>

void print_bits(unsigned int n) {
    for (int i = 7; i >= 0; i--) {
        printf("%d", (n >> i) & 1);
    }
    printf("\n");
}

int main(void) {
    unsigned int a = 0b10101010; /* 170 */
    unsigned int b = 0b11001100; /* 204 */

    printf("a     = "); print_bits(a);     /* 10101010 */
    printf("b     = "); print_bits(b);     /* 11001100 */
    printf("a & b = "); print_bits(a & b); /* 10001000 (AND) */
    printf("a | b = "); print_bits(a | b); /* 11101110 (OR) */
    printf("a ^ b = "); print_bits(a ^ b); /* 01100110 (XOR) */
    printf("~a    = "); print_bits(~a);    /* 01010101 (NOT, low 8 bits) */

    /* Shift operators */
    unsigned int x = 1;
    printf("1 << 3 = %u\n", x << 3);  /* 8 (multiply by 2^3) */
    printf("8 >> 2 = %u\n", 8u >> 2);  /* 2 (divide by 2^2) */

    /* Practical: extract a bit */
    unsigned int val = 0xA5; /* 10100101 */
    int bit3 = (val >> 3) & 1;
    printf("bit 3 of 0xA5 = %d\n", bit3); /* 0 */

    /* Practical: set a bit */
    val = val | (1 << 3); /* set bit 3 */
    printf("after set bit 3: 0x%X\n", val); /* 0xAD */

    return 0;
}

a     = 10101010
b     = 11001100
a & b = 10001000
a | b = 11101110
a ^ b = 01100110
~a    = 01010101
1 << 3 = 8
8 >> 2 = 2
bit 3 of 0xA5 = 0
after set bit 3: 0xAD

Key Points

•& masks bits; | sets bits; ^ toggles bits; ~ flips all bits
•<< multiplies by 2^n; >> divides by 2^n (for unsigned)
•Bitwise operators work only on integer types, not floats
•Right shift of signed negative values is implementation-defined
•Use unsigned types for predictable bitwise behavior

Gotchas

•Right-shifting a negative signed integer is implementation-defined (arithmetic vs logical shift)
•Left-shifting into or past the sign bit is undefined behavior for signed types
•~0 is -1 on two's complement systems (all bits set), not 0
•Shifting by negative amount or by >= width of type is undefined behavior

& = AND (mask), | = OR (set), ^ = XOR (toggle), ~ = NOT (flip), << = left shift, >> = right shift. Use unsigned types for predictable behavior. Shifting by >= type width is UB.

•& masks, | sets, ^ toggles, ~ flips all
•Always use unsigned for bit manipulation

#include <stdio.h>
int main(void) {
    unsigned int x = 0xA5; /* 10100101 */
    printf("x & 0x0F = 0x%X\n", x & 0x0F); /* 0x05 (mask) */
    printf("x | 0x10 = 0x%X\n", x | 0x10); /* 0xB5 (set) */
    printf("x ^ 0xFF = 0x%X\n", x ^ 0xFF); /* 0x5A (toggle) */
    printf("x << 4   = 0x%X\n", x << 4);   /* 0xA50 */
    return 0;
}

x & 0x0F = 0x5
x | 0x10 = 0xB5
x ^ 0xFF = 0x5A
x << 4   = 0xA50

Shifting by >= type width is undefined behavior

Question 4 / 12

How do assignment operators and compound assignment work?

Simple assignment (=): Assigns the right-hand side value to the left-hand side variable. The assignment expression itself has a value (the assigned value), which enables chaining.

Compound assignment operators: Combine an operation with assignment.

+=, -=, *=, /=, %= (arithmetic)
&=, |=, ^= (bitwise)
<<=, >>= (shift)

x op= y is equivalent to x = x op (y) except that x is evaluated only once. This matters when x has side effects (e.g., arr[i++] += 5).

Assignment chaining: a = b = c = 0 works because = is right-associative and returns the assigned value. It evaluates as a = (b = (c = 0)).

Pseudo Code

1. x = value;     // simple assignment
2. x += y;        // equivalent to x = x + (y)
3. x <<= n;       // equivalent to x = x << (n)
4. a = b = c = 0; // right-associative chaining
5. x is evaluated only once in compound assignment

Code

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5:  %d\n", x);  /* 15 */
    x -= 3;   printf("x -= 3:  %d\n", x);  /* 12 */
    x *= 2;   printf("x *= 2:  %d\n", x);  /* 24 */
    x /= 4;   printf("x /= 4:  %d\n", x);  /* 6  */
    x %= 4;   printf("x %%= 4:  %d\n", x); /* 2  */

    /* Bitwise compound */
    unsigned int flags = 0x00;
    flags |= 0x01;  /* set bit 0 */
    flags |= 0x04;  /* set bit 2 */
    printf("flags = 0x%02X\n", flags); /* 0x05 */
    flags &= ~0x01; /* clear bit 0 */
    printf("flags = 0x%02X\n", flags); /* 0x04 */

    /* Assignment chaining */
    int a, b, c;
    a = b = c = 42;
    printf("a=%d b=%d c=%d\n", a, b, c); /* 42 42 42 */

    /* Assignment as expression value */
    int n;
    if ((n = 5) > 0) {
        printf("n = %d\n", n); /* 5 */
    }

    return 0;
}

x += 5:  15
x -= 3:  12
x *= 2:  24
x /= 4:  6
x %= 4:  2
flags = 0x05
flags = 0x04
a=42 b=42 c=42
n = 5

Key Points

•Compound assignment: x op= y means x = x op (y) with x evaluated once
•Assignment is right-associative: a = b = c = 0
•The assignment expression itself has a value (the assigned value)
•Single evaluation matters: arr[i++] += 1 increments i only once
•Bitwise compound operators are common for flag manipulation

Gotchas

•= is assignment, == is comparison -- classic C bug source
•if (x = 5) is valid C (assigns 5 to x, evaluates to 5 which is true) -- usually a bug
•Compound assignment may involve implicit type conversion: char c = 200; c += 100; wraps
•x = x + y may differ from x += y if x has side effects (evaluated twice vs once)

x += y is x = x + (y) with x evaluated once. Chaining: a = b = c = 0 (right-to-left). Assignment expressions have a value. Bitwise compounds (|=, &=) are common for flags.

•x op= y evaluates x only once
•= is right-associative; expression value is the assigned value

#include <stdio.h>
int main(void) {
    int x = 10;
    x += 5; /* 15 */
    x *= 2; /* 30 */
    unsigned int flags = 0;
    flags |= 0x03; /* set bits 0,1 */
    flags &= ~0x01; /* clear bit 0 */
    printf("x=%d flags=0x%X\n", x, flags);
    return 0;
}

x=30 flags=0x2

= vs == is the most common C bug

Question 5 / 12

How does the ternary (conditional) operator work?

The ternary operator condition ? expr1 : expr2 is C's only operator that takes three operands.

How it works:

condition is evaluated.
If true (non-zero): expr1 is evaluated and is the result.
If false (zero): expr2 is evaluated and is the result.
Only ONE of expr1 or expr2 is evaluated (like short-circuit).

Type rules: The result type follows the usual arithmetic conversions applied to expr1 and expr2.

Common uses:

Inline min/max: int min = (a < b) ? a : b;
Conditional assignment: char *s = (n == 1) ? "item" : "items";
Return values: return (x > 0) ? x : -x;

The ternary operator can be nested, but deeply nested ternaries are hard to read and should be avoided.

Pseudo Code

1. condition ? value_if_true : value_if_false
2. Only one branch is evaluated
3. Result type follows usual arithmetic conversions
4. Parenthesize when used in larger expressions
5. Can be nested but avoid deep nesting

Code

#include <stdio.h>

int main(void) {
    int a = 10, b = 20;

    /* Basic usage */
    int min = (a < b) ? a : b;
    printf("min(%d, %d) = %d\n", a, b, min); /* 10 */

    /* Absolute value */
    int x = -5;
    int abs_x = (x >= 0) ? x : -x;
    printf("|%d| = %d\n", x, abs_x); /* 5 */

    /* Conditional string */
    int count = 1;
    printf("%d %s\n", count, (count == 1) ? "item" : "items");
    /* 1 item */

    /* Only one branch is evaluated */
    int n = 0;
    int result = (1) ? (n = 10) : (n = 20);
    printf("n = %d\n", n); /* 10, not 20 */

    /* Nested (avoid in practice) */
    int score = 85;
    char grade = (score >= 90) ? 'A' :
                 (score >= 80) ? 'B' :
                 (score >= 70) ? 'C' : 'F';
    printf("grade = %c\n", grade); /* B */

    return 0;
}

min(10, 20) = 10
|-5| = 5
1 item
n = 10
grade = B

Key Points

•condition ? expr_true : expr_false -- only one branch evaluated
•Result type follows usual arithmetic conversions
•Use parentheses for clarity in complex expressions
•Good for simple inline conditions (min, max, abs)
•Nested ternaries reduce readability -- prefer if/else

Gotchas

•Ternary has very low precedence: printf("%d", x > 0 ? x : -x) needs parens around the ternary
•The two branches can have different types, causing implicit conversion
•Cannot use statements (like return) inside ternary -- only expressions
•Nested ternaries without parentheses are a readability nightmare

cond ? a : b evaluates to a if cond is true, b otherwise. Only one branch is evaluated. Use for simple inline conditions. Parenthesize in larger expressions.

•Only one branch is evaluated
•Parenthesize when embedding in larger expressions

#include <stdio.h>
int main(void) {
    int a = 10, b = 20;
    int min = (a < b) ? a : b;
    printf("min = %d\n", min); /* 10 */
    return 0;
}

min = 10

Very low precedence -- always parenthesize in printf or assignments

Question 6 / 12

What is the comma operator and how does it work?

The comma operator evaluates two expressions from left to right and returns the value of the right expression. The left expression is evaluated only for its side effects.

Syntax: (expr1, expr2) -- evaluates expr1, discards its value, evaluates expr2, returns its value.

Important: The comma in function arguments f(a, b) and variable declarations int a, b; is NOT the comma operator -- it is a separator.

The comma operator introduces a sequence point, meaning all side effects of expr1 are complete before expr2 begins.

Common uses:

Multiple expressions in for-loop init/update: for (i = 0, j = n; i < j; i++, j--)
Macro tricks (evaluating multiple statements as one expression).
Rarely used elsewhere -- overusing it hurts readability.

Pseudo Code

1. (expr1, expr2) -> evaluate expr1, discard, evaluate expr2, return
2. Introduces a sequence point between expr1 and expr2
3. Comma in f(a, b) is a separator, NOT the comma operator
4. Common in for-loop: for (i=0, j=n; ...; i++, j--)
5. Has the lowest precedence of all C operators

Code

#include <stdio.h>

int main(void) {
    /* Comma operator: left evaluated, right returned */
    int x = (1, 2, 3);
    printf("x = %d\n", x); /* 3 (last value) */

    /* Side effects in left operand */
    int a = 0;
    int b = (a = 5, a + 10);
    printf("a=%d b=%d\n", a, b); /* a=5 b=15 */

    /* Common use: multiple updates in for-loop */
    for (int i = 0, j = 5; i < j; i++, j--) {
        printf("i=%d j=%d\n", i, j);
    }
    /* Output: i=0 j=5, i=1 j=4, i=2 j=3 */

    /* NOT the comma operator (function argument separator) */
    printf("%d %d\n", 10, 20); /* comma here is a separator */

    /* Lowest precedence */
    int y;
    y = 1, 2;  /* y = 1 (assignment binds tighter than comma) */
    printf("y = %d\n", y); /* 1, not 2 */

    y = (1, 2); /* now y = 2 (parentheses force comma operator) */
    printf("y = %d\n", y); /* 2 */

    return 0;
}

x = 3
a=5 b=15
i=0 j=5
i=1 j=4
i=2 j=3
10 20
y = 1
y = 2

Key Points

•Evaluates left to right, returns the rightmost value
•Introduces a sequence point between operands
•Has the lowest precedence of all operators
•Most commonly used in for-loop init and update expressions
•Comma in function calls and declarations is a separator, not an operator

Gotchas

•y = 1, 2; assigns 1 to y (= binds tighter), not 2
•Overusing comma operator makes code hard to read
•The comma in int a, b; is NOT the comma operator
•The comma in f(a, b) is NOT the comma operator -- but f((a, b)) uses it

Comma operator (expr1, expr2) evaluates both left-to-right, returns the right value. Has the lowest precedence. Most common use: for (i=0, j=n; ...; i++, j--). The comma in function calls is a separator, not this operator.

•Returns the rightmost value
•Lowest precedence of all operators

#include <stdio.h>
int main(void) {
    int x = (1, 2, 3);   /* x = 3 */
    int y;
    y = 1, 2;            /* y = 1 (= binds tighter) */
    printf("x=%d y=%d\n", x, y);
    return 0;
}

x=3 y=1

y = 1, 2; assigns 1, not 2 -- = has higher precedence than comma

Question 7 / 12

What is operator precedence and associativity in C?

Precedence determines which operator is evaluated first when multiple operators are in one expression. Higher precedence operators bind tighter.

Associativity determines the order when operators of the same precedence appear. It can be left-to-right or right-to-left.

Key precedence levels (highest to lowest):

() [] -> . (postfix ++/--) -- left-to-right
Unary: prefix ++/--, * & ~ ! sizeof (type) -- right-to-left
* / % -- left-to-right
+ - -- left-to-right
<< >> -- left-to-right
< <= > >= -- left-to-right
== != -- left-to-right
& (bitwise AND)
^ (bitwise XOR)
| (bitwise OR)
&& (logical AND)
|| (logical OR)
?: (ternary) -- right-to-left
= += etc. -- right-to-left
, (comma) -- left-to-right

Common pitfall: Bitwise operators have LOWER precedence than comparison operators. x & 0xFF == 0 is parsed as x & (0xFF == 0), not (x & 0xFF) == 0.

Pseudo Code

Highest to lowest precedence:
1. Postfix: () [] -> . ++ --
2. Unary: ++ -- * & ~ ! sizeof (type)
3. Multiplicative: * / %
4. Additive: + -
5. Shift: << >>
6. Relational: < <= > >=
7. Equality: == !=
8. Bitwise AND: &
9. Bitwise XOR: ^
10. Bitwise OR: |
11. Logical AND: &&
12. Logical OR: ||
13. Ternary: ?:
14. Assignment: = += etc.
15. Comma: ,

Code

#include <stdio.h>

int main(void) {
    /* Precedence: * before + */
    int a = 2 + 3 * 4;   /* 2 + 12 = 14, not 20 */
    printf("%d\n", a);    /* 14 */

    /* CLASSIC BUG: bitwise & has lower precedence than == */
    int x = 5;  /* binary: 0101 */
    /* if (x & 1 == 0)   // WRONG: parsed as x & (1 == 0) = x & 0 = 0 */
    if ((x & 1) == 0) {  /* CORRECT: test if x is even */
        printf("even\n");
    } else {
        printf("odd\n"); /* This prints */
    }

    /* Associativity: right-to-left for assignment */
    int p, q, r;
    p = q = r = 10;  /* r=10, then q=10, then p=10 */
    printf("p=%d q=%d r=%d\n", p, q, r);

    /* Associativity: left-to-right for arithmetic */
    int result = 10 - 5 - 2;  /* (10-5)-2 = 3, not 10-(5-2)=7 */
    printf("%d\n", result);    /* 3 */

    /* When in doubt, use parentheses! */
    int y = ((2 + 3) * 4);  /* clearly 20 */
    printf("%d\n", y);

    return 0;
}

14
odd
p=10 q=10 r=10
3
20

Key Points

•Precedence determines which operator binds first
•Associativity resolves ties between same-precedence operators
•Bitwise operators have lower precedence than comparisons -- always parenthesize
•Assignment is right-to-left associative: a = b = c = 0
•When in doubt, use parentheses for clarity

Gotchas

•x & 1 == 0 is x & (1 == 0), not (x & 1) == 0 -- always parenthesize bitwise with comparisons
•x = y == z is x = (y == z), not (x = y) == z
•Precedence does NOT define evaluation order -- a + b * c evaluates * first but a or b could be computed in either order
•Ternary operator has very low precedence: a + b ? c : d is (a + b) ? c : d

Precedence determines binding order (* before +). Associativity resolves ties (left-to-right or right-to-left). The biggest trap: bitwise & | ^ have lower precedence than == !=. Always parenthesize bitwise expressions.

•Bitwise ops have lower precedence than comparisons
•When in doubt, parenthesize

#include <stdio.h>
int main(void) {
    int x = 5;
    /* BUG: x & 1 == 0 means x & (1 == 0) */
    /* FIX: (x & 1) == 0 */
    printf("%d\n", (x & 1) == 0); /* 0 (odd) */
    printf("%d\n", 2 + 3 * 4);    /* 14 */
    return 0;
}

0
14

x & 1 == 0 is parsed as x & (1 == 0), almost always a bug

Question 8 / 12

How do implicit type conversions (promotions) work in expressions?

When operands in an expression have different types, C automatically converts them using a set of rules called the usual arithmetic conversions.

Step 1: Integer promotion Types smaller than int (char, short, bit-fields) are promoted to int (or unsigned int).

Step 2: Usual arithmetic conversions If operands still differ after promotion:

If either is long double, the other converts to long double.
If either is double, the other converts to double.
If either is float, the other converts to float.
Otherwise (both integer types): the "narrower" type converts to the "wider" type, with complex signed/unsigned rules.

Signed/unsigned conversion rule: If the unsigned type has the same or greater rank, the signed value converts to unsigned. This can produce surprising results with negative values.

Pseudo Code

1. Integer promotion: char/short -> int
2. If either is long double -> both long double
3. If either is double -> both double
4. If either is float -> both float
5. Otherwise: narrower integer -> wider integer
6. signed + unsigned (same rank) -> unsigned

Code

#include <stdio.h>

int main(void) {
    /* int + double -> double */
    int i = 5;
    double d = 2.5;
    printf("5 + 2.5 = %f\n", i + d); /* 7.500000 (double) */

    /* int + float -> float */
    float f = 3.0f;
    printf("5 + 3.0f = %f\n", i + f); /* 8.000000 */

    /* int + unsigned int -> unsigned int */
    int neg = -1;
    unsigned int pos = 1;
    printf("-1 + 1u = %u\n", neg + pos); /* 0 (correct by luck) */
    printf("-1 > 1u? %d\n", neg > pos);  /* 1 (true! -1 -> UINT_MAX) */

    /* char arithmetic -> promoted to int */
    char a = 100, b = 50;
    printf("sizeof(a+b) = %zu\n", sizeof(a + b)); /* sizeof(int) */

    /* Integer division vs float division */
    printf("5/2   = %d\n", 5 / 2);          /* 2 (int division) */
    printf("5/2.0 = %f\n", 5 / 2.0);        /* 2.500000 (promoted) */
    printf("(double)5/2 = %f\n", (double)5 / 2); /* 2.500000 */

    return 0;
}

5 + 2.5 = 7.500000
5 + 3.0f = 8.000000
-1 + 1u = 0
-1 > 1u? 1
sizeof(a+b) = 4
5/2   = 2
5/2.0 = 2.500000
(double)5/2 = 2.500000

Key Points

•Smaller types are promoted to int before arithmetic
•Mixed int/float operations promote to the wider floating type
•Integer division stays integer unless one operand is float/double
•signed + unsigned = unsigned (same rank): signed converts to unsigned
•Cast one operand to force the desired conversion

Gotchas

•-1 > 1u is TRUE because -1 is converted to UINT_MAX
•5/2 is 2 (integer division); 5/2.0 is 2.5 (float promotion)
•char + char yields int, not char
•Assigning a double to an int silently truncates: int x = 3.9; gives x=3

C promotes smaller types to int, then converts to the wider type in mixed expressions. int + double -> double. signed + unsigned (same rank) -> unsigned. 5/2 is int division (2); 5/2.0 is float division (2.5).

•Mixed types promote to the wider type
•Integer division stays integer unless one operand is float

#include <stdio.h>
int main(void) {
    printf("%f\n", 5 / 2.0);  /* 2.500000 (promoted) */
    printf("%d\n", 5 / 2);    /* 2 (int division) */
    printf("%d\n", -1 > 1u);  /* 1 (true! surprise) */
    return 0;
}

2.500000
2
1

-1 > 1u is true because -1 becomes UINT_MAX

Question 9 / 12

How does explicit casting work in C?

Explicit casting forces a type conversion using the cast operator: (type)expression.

Common uses:

Force float division: (double)a / b instead of a / b (integer division).
Truncate float to int: (int)3.7 gives 3 (truncation toward zero).
Pointer casting: (int *)void_ptr to convert void pointers.
Suppress warnings: (void)unused_variable; tells the compiler you intentionally ignore it.
Narrow conversions: (char)256 wraps to 0 (for unsigned char).

Cast vs conversion:

Cast is explicit syntax: (type)expr.
Conversion can be implicit (automatic) or explicit (cast).
Explicit casts suppress compiler warnings, which can hide real bugs.

Pseudo Code

1. (type)expression -- force conversion to type
2. (double)a / b -- force float division
3. (int)3.7 -> 3 (truncate toward zero)
4. (void)x -- suppress unused variable warning
5. Casts suppress warnings -- use carefully

Code

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

int main(void) {
    /* Force float division */
    int a = 5, b = 2;
    printf("5/2 = %d\n", a / b);             /* 2 */
    printf("5/2 = %f\n", (double)a / b);     /* 2.500000 */

    /* Truncate float to int */
    double pi = 3.14159;
    int truncated = (int)pi;
    printf("(int)3.14159 = %d\n", truncated); /* 3 */
    printf("(int)-3.7 = %d\n", (int)-3.7);   /* -3 (toward zero) */

    /* Pointer casting */
    void *ptr = malloc(sizeof(int));
    if (ptr) {
        int *ip = (int *)ptr; /* explicit cast (optional in C, required in C++) */
        *ip = 42;
        printf("*ip = %d\n", *ip);
        free(ptr);
    }

    /* Suppress unused warning */
    int unused = 0;
    (void)unused; /* tell compiler: intentionally unused */

    /* Dangerous: narrow cast with data loss */
    int big = 300;
    char small = (char)big; /* truncated! */
    printf("(char)300 = %d\n", small); /* platform-dependent, likely 44 */

    return 0;
}

5/2 = 2
5/2 = 2.500000
(int)3.14159 = 3
(int)-3.7 = -3
*ip = 42
(char)300 = 44

Key Points

•(type)expr forces explicit type conversion
•Common for forcing float division and truncating to int
•Casts suppress compiler warnings -- can hide bugs
•(void)x is idiomatic for suppressing unused variable warnings
•In C, void* to typed pointer needs no cast (unlike C++)

Gotchas

•Casting does NOT change the original variable -- it creates a temporary converted value
•Casting a float to int truncates toward zero, does NOT round
•Casting between unrelated pointer types (except void*) can violate strict aliasing rules
•Casting can hide bugs: casting away const and writing through the pointer is UB

(type)expr forces a conversion. (double)5/2 gives 2.5. (int)3.7 gives 3 (truncation). (void)x suppresses unused warnings. Casts hide compiler warnings, so use carefully.

•(double)a / b forces float division
•(int)float truncates toward zero

#include <stdio.h>
int main(void) {
    printf("%f\n", (double)5 / 2); /* 2.500000 */
    printf("%d\n", (int)3.7);      /* 3 */
    printf("%d\n", (int)-3.7);     /* -3 */
    return 0;
}

2.500000
3
-3

Casting hides warnings -- may mask real type errors

Question 10 / 12

What are sequence points in C and why do they matter?

A sequence point is a point in the program's execution at which all previous side effects are guaranteed to be complete, and no subsequent side effects have started.

Where sequence points occur:

End of a full expression (the ; in a statement).
Between the left and right operands of &&, ||, and ,.
Between the condition and the selected branch of ?:.
At a function call (after argument evaluation, before the call).
At the end of an initializer.

Why they matter: Between two sequence points, a variable may be modified at most once. Violating this is undefined behavior.

i = i++ modifies i twice between sequence points -- this is UB. The result could be anything.

Not sequence points: +, -, *, function argument separators (,). The order of evaluation of function arguments is unspecified.

Pseudo Code

1. Sequence point = all prior side effects complete
2. Rule: each variable modified at most once between sequence points
3. Violation = undefined behavior
4. i = i++ is UB (double modification)
5. Sequence points: ; && || , ?: function call
6. NOT sequence points: + - * / function argument commas

Code

#include <stdio.h>

int main(void) {
    /* UNDEFINED BEHAVIOR: i modified twice between sequence points */
    /* int i = 1;
       i = i++;  // UB: could be 1, 2, or anything */

    /* UNDEFINED BEHAVIOR: using and modifying same variable */
    /* int a = 1;
       int b = a + a++;  // UB: order of + operands is unspecified */

    /* SAFE: sequence point between && operands */
    int i = 0;
    if (i == 0 && ++i == 1) {
        printf("i = %d\n", i); /* 1 -- safe, && is a sequence point */
    }

    /* SAFE: separate statements have sequence points */
    int x = 5;
    x = x + 1;  /* OK: only one modification between ; */
    printf("x = %d\n", x); /* 6 */

    /* UNSPECIFIED: order of function argument evaluation */
    int n = 0;
    /* printf("%d %d\n", n++, n++); // UB: n modified twice */
    /* Instead, do: */
    int a_val = n++;
    int b_val = n++;
    printf("%d %d\n", a_val, b_val); /* 0 1 */

    return 0;
}

i = 1
x = 6
0 1

Key Points

•A sequence point guarantees all prior side effects are complete
•Between two sequence points, modify each variable at most once
•&&, ||, ?:, comma operator, and ; are sequence points
•Function argument evaluation order is unspecified
•Violating sequence point rules is undefined behavior

Gotchas

•i = i++ is undefined behavior -- result is unpredictable
•printf("%d %d", i++, i++) is UB -- commas in function calls are NOT sequence points
•a[i] = i++ is UB -- i is read and modified between the same sequence points
•The compiler can do ANYTHING with UB code -- it might work today and fail tomorrow

A sequence point guarantees all prior side effects are complete. Between two sequence points, modify each variable at most once. i = i++ is UB. Sequence points: ;, &&, ||, ?:, comma operator, function calls.

•Modify each variable at most once between sequence points
•i = i++ is undefined behavior

#include <stdio.h>
int main(void) {
    /* SAFE */
    int i = 0;
    i++;       /* ; is a sequence point */
    printf("%d\n", i); /* 1 */

    /* UB: i = i++;  -- do NOT write this */
    /* UB: printf("%d %d", i++, i++); */
    return 0;
}

Function argument commas are NOT sequence points

Question 11 / 12

What is undefined behavior in expressions and how do you avoid it?

Undefined behavior (UB) means the C standard imposes no requirements -- the program can do anything: crash, produce wrong results, appear to work, or format your hard drive.

Common UB in expressions:

Signed integer overflow: INT_MAX + 1
Division by zero: x / 0
Shift by negative or >= width: 1 << 32 (if int is 32-bit)
Double modification between sequence points: i = i++
Accessing uninitialized variables: int x; printf("%d", x);
Dereferencing NULL pointer: *((int *)NULL)
Buffer overflow: arr[10] when array has 5 elements

Why UB is dangerous: Compilers assume UB never happens and optimize accordingly. This can remove safety checks, reorder code, or produce completely unexpected behavior. UB is not just "implementation-defined" -- it is truly anything goes.

How to avoid:

Enable warnings: gcc -Wall -Wextra -Werror
Use sanitizers: -fsanitize=undefined
Static analyzers: clang-tidy, cppcheck
Code reviews and defensive coding

Pseudo Code

Common UB sources:
1. Signed overflow: INT_MAX + 1
2. Division by zero: x / 0
3. Bad shifts: 1 << 32 (32-bit int)
4. Sequence point violation: i = i++
5. Uninitialized reads: int x; use x;
6. Null dereference: *NULL
7. Buffer overflow: arr[out_of_bounds]

Defense:
- gcc -Wall -Wextra -Werror
- -fsanitize=undefined
- Always initialize variables

Code

#include <stdio.h>
#include <limits.h>

int main(void) {
    /* SAFE: check before dividing */
    int a = 10, b = 0;
    if (b != 0) {
        printf("%d\n", a / b);
    } else {
        printf("Division by zero avoided\n");
    }

    /* SAFE: check before signed arithmetic */
    int x = INT_MAX;
    int y = 1;
    if (y > 0 && x > INT_MAX - y) {
        printf("Overflow would occur\n");
    } else if (y > 0) {
        printf("%d\n", x + y);
    }

    /* SAFE: check shift amount */
    int shift = 31;
    if (shift >= 0 && shift < (int)(sizeof(int) * 8)) {
        printf("1 << %d = %d\n", shift, 1 << shift);
    }

    /* SAFE: always initialize variables */
    int initialized = 0; /* not garbage */
    printf("%d\n", initialized);

    /* Compile with: gcc -Wall -Wextra -fsanitize=undefined prog.c */

    return 0;
}

Division by zero avoided
Overflow would occur
1 << 31 = -2147483648
0

Key Points

•UB means the program can do literally anything
•Compilers assume UB never happens and optimize based on that assumption
•Always validate inputs before operations that can cause UB
•Enable compiler warnings: -Wall -Wextra -Werror
•Use sanitizers: -fsanitize=undefined catches UB at runtime

Gotchas

•UB code that works today may break with a compiler update or different optimization level
•The compiler can REMOVE your overflow check if it assumes signed overflow is UB
•UB can have retroactive effects: code BEFORE the UB can behave unexpectedly
•Implementation-defined behavior (like right-shifting signed values) is NOT the same as UB

Undefined behavior means anything can happen. Common sources: signed overflow, division by zero, bad shifts, sequence point violations, uninitialized reads. The compiler assumes UB never happens and optimizes aggressively. Use -Wall -Wextra -fsanitize=undefined.

•UB = anything can happen; compiler assumes it never occurs
•Use -Wall -Wextra -fsanitize=undefined

#include <stdio.h>
#include <limits.h>
int main(void) {
    /* Always check before risky operations */
    int x = INT_MAX, y = 1;
    if (y > 0 && x <= INT_MAX - y) {
        printf("%d\n", x + y); /* safe */
    } else {
        printf("overflow prevented\n");
    }
    return 0;
}

overflow prevented

Compilers can remove your safety checks if they assume UB cannot happen

Question 12 / 12

How does the sizeof operator behave with different expressions?

The sizeof operator behaves differently depending on what it is applied to:

1. Types: sizeof(int) -- parentheses required for type names. 2. Variables: sizeof x or sizeof(x) -- parentheses optional for expressions. 3. Arrays: sizeof(arr) -- gives the total size in bytes. 4. Pointers: sizeof(ptr) -- gives pointer size (4 or 8 bytes), NOT the size of pointed-to data. 5. Strings: sizeof("hello") -- includes the null terminator (6, not 5). 6. Struct: sizeof(struct S) -- may include padding bytes. 7. Expressions: sizeof(a + b) -- uses the result type; does NOT evaluate the expression.

VLA exception (C99): For variable-length arrays, sizeof is evaluated at runtime, not compile time.

Compile-time nature: sizeof(arr) is determined at compile time (except VLAs). The expression inside sizeof is NOT evaluated -- only its type matters.

Pseudo Code

sizeof(type)    -> size of that type
sizeof(variable) -> size of variable's type
sizeof(array)   -> total bytes (count * element_size)
sizeof(pointer) -> pointer size (4 or 8)
sizeof("str")   -> includes null terminator
sizeof(expr)    -> size of result type (expr not evaluated)
sizeof(struct)  -> may include padding

Code

#include <stdio.h>

struct Padded {
    char c;   /* 1 byte + 3 padding */
    int x;    /* 4 bytes */
};             /* total: likely 8, not 5 */

int main(void) {
    /* Type */
    printf("sizeof(int)   = %zu\n", sizeof(int));    /* 4 */
    printf("sizeof(char)  = %zu\n", sizeof(char));   /* 1 (always) */

    /* Array */
    int arr[10];
    printf("sizeof(arr)   = %zu\n", sizeof(arr));    /* 40 */
    printf("elements      = %zu\n", sizeof(arr)/sizeof(arr[0])); /* 10 */

    /* Pointer */
    int *p = arr;
    printf("sizeof(p)     = %zu\n", sizeof(p));      /* 8 on 64-bit */

    /* String literal (includes '\0') */
    printf("sizeof(\"hello\") = %zu\n", sizeof("hello")); /* 6 */

    /* Struct with padding */
    printf("sizeof(Padded)= %zu\n", sizeof(struct Padded)); /* likely 8 */

    /* Expression not evaluated */
    int x = 5;
    printf("sizeof(x++)   = %zu\n", sizeof(x++)); /* sizeof(int) */
    printf("x = %d\n", x); /* still 5! */

    /* Result type of expression */
    char a = 1;
    short b = 2;
    printf("sizeof(a+b)   = %zu\n", sizeof(a + b)); /* sizeof(int) */

    return 0;
}

sizeof(int)   = 4
sizeof(char)  = 1
sizeof(arr)   = 40
elements      = 10
sizeof(p)     = 8
sizeof("hello") = 6
sizeof(Padded)= 8
sizeof(x++)   = 4
x = 5
sizeof(a+b)   = 4

Key Points

•sizeof returns size_t; print with %zu
•Expression inside sizeof is NOT evaluated (except VLAs)
•sizeof(string_literal) includes the null terminator
•sizeof(struct) may include padding bytes
•sizeof(char + short) is sizeof(int) due to integer promotion

Gotchas

•sizeof("hello") is 6 (5 chars + null), not 5
•sizeof(struct) may be larger than the sum of member sizes due to padding
•sizeof applied to a function parameter that was an array gives pointer size
•sizeof(x++) does not increment x

sizeof gives byte size at compile time. Arrays give total size, pointers give pointer size, strings include \0, structs may include padding, and expressions are NOT evaluated.

•sizeof(string) includes null terminator
•sizeof(arr) gives total bytes, not element count

#include <stdio.h>
int main(void) {
    int arr[5];
    printf("%zu %zu %zu\n",
        sizeof(arr),       /* 20 */
        sizeof("hello"),   /* 6 (includes \0) */
        sizeof(arr[0]));   /* 4 */
    return 0;
}

20 6 4

sizeof("hello") is 6, not 5

Built by onllm.dev

Home GitHub Support awesomePrep