← Data Types, Variables & Storage Classes

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

What are the basic data types in C and their typical sizes?

The C standard defines integer types by minimum numeric range, not by byte size. A byte (sizeof(char) == 1) is at least 8 bits (CHAR_BIT >= 8), but some platforms (notably DSP chips) use 16-bit or 32-bit bytes, which shifts all sizeof values.

1. char -- stores a single character or small integer.

Minimum range: -127 to 127 (signed) or 0 to 255 (unsigned). Whether plain char is signed or unsigned is implementation-defined.
sizeof(char) is always 1, but 1 byte is not always 8 bits.

2. int -- general-purpose integer.

Minimum range: -32,767 to 32,767 (the standard requires at least 16 bits of value).
On most modern 32/64-bit desktops it holds -2,147,483,648 to 2,147,483,647 (32-bit), but that is not guaranteed.
Modifiers: short (>= 16-bit range), long (>= 32-bit range), long long (>= 64-bit range).

3. float -- single-precision floating point.

Typically IEEE 754 binary32 (4 bytes on most platforms).
Precision: ~6-7 significant decimal digits.

4. double -- double-precision floating point.

Typically IEEE 754 binary64 (8 bytes on most platforms).
Precision: ~15-16 significant decimal digits.

5. void -- represents the absence of type.

Used for functions that return nothing, generic pointers (void *), and to indicate no parameters f(void).

The standard guarantees these minimum ranges (C11 5.2.4.2.1) and this ordering:

sizeof(char) == 1 (always, by definition)
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)
Use <limits.h> for the actual ranges and CHAR_BIT for bits per byte on your platform.

Pseudo Code

1. char: sizeof==1 (but 1 byte >= 8 bits, not always exactly 8)
2. int: minimum range -32767..32767, typically 32-bit on desktops
3. float: ~7 decimal digits precision (usually IEEE 754)
4. double: ~15 decimal digits precision (usually IEEE 754)
5. void: no value, used for function returns and generic pointers
6. Modifiers: short, long, long long, signed, unsigned
7. The standard defines types by minimum range, not byte count

Code

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

int main(void) {
    printf("char:      %zu byte(s), range: %d to %d\n",
           sizeof(char), CHAR_MIN, CHAR_MAX);
    printf("short:     %zu byte(s), range: %d to %d\n",
           sizeof(short), SHRT_MIN, SHRT_MAX);
    printf("int:       %zu byte(s), range: %d to %d\n",
           sizeof(int), INT_MIN, INT_MAX);
    printf("long:      %zu byte(s), range: %ld to %ld\n",
           sizeof(long), LONG_MIN, LONG_MAX);
    printf("long long: %zu byte(s), range: %lld to %lld\n",
           sizeof(long long), LLONG_MIN, LLONG_MAX);
    printf("float:     %zu byte(s), precision: %d digits\n",
           sizeof(float), FLT_DIG);
    printf("double:    %zu byte(s), precision: %d digits\n",
           sizeof(double), DBL_DIG);
    return 0;
}

char:      1 byte(s), range: -128 to 127
short:     2 byte(s), range: -32768 to 32767
int:       4 byte(s), range: -2147483648 to 2147483647
long:      8 byte(s), range: -9223372036854775808 to 9223372036854775807
long long: 8 byte(s), range: -9223372036854775808 to 9223372036854775807
float:     4 byte(s), precision: 6 digits
double:    8 byte(s), precision: 15 digits

Key Points

•C defines integer types by minimum numeric range, not byte size
•sizeof(char) is always 1, but a byte is at least 8 bits (CHAR_BIT >= 8), not always exactly 8
•int must hold at least -32767 to 32767; it is typically 32-bit on desktops but not guaranteed
•void is not a real type -- you cannot declare a void variable
•Use <limits.h> and <float.h> to check actual ranges on your platform

Gotchas

•The standard defines types by minimum range, not byte count -- some DSP chips have 16-bit or 32-bit char, shifting all sizeof values
•int is NOT guaranteed to be 4 bytes -- on some platforms it is 2 bytes
•Whether plain char is signed or unsigned is implementation-defined
•sizeof returns size_t (unsigned), use %zu format specifier
•long is 4 bytes on Windows 64-bit but 8 bytes on Linux 64-bit (LLP64 vs LP64)

C defines integer types by minimum numeric range, not byte size. char is always sizeof 1 but a byte is at least 8 bits (CHAR_BIT), not always exactly 8. int must hold at least -32,767 to 32,767 (typically 32-bit on desktops). float and double are usually IEEE 754. Modifiers like short, long, signed, unsigned change the range. Use <limits.h> for actual ranges on your platform.

•C defines types by minimum range, not byte size -- sizeof(char) == 1 always but a byte >= 8 bits
•Use <limits.h> for INT_MIN/INT_MAX and CHAR_BIT for bits per byte

#include <stdio.h>
int main(void) {
    printf("char=%zu int=%zu float=%zu double=%zu\n",
           sizeof(char), sizeof(int),
           sizeof(float), sizeof(double));
    return 0;
}

char=1 int=4 float=4 double=8

int size is platform-dependent -- never assume 4 bytes; some DSP chips have 16-bit or 32-bit char

Question 2 / 15

How does the sizeof operator work in C?

sizeof is a compile-time unary operator that returns the size (in bytes) of its operand. It can take a type name (in parentheses) or an expression.

Key points:

Returns a value of type size_t (defined in <stddef.h>).
When applied to an expression, the expression is NOT evaluated -- only its type is examined.
For arrays, sizeof(arr) gives the total size of the array in bytes (not the number of elements).
For pointers, sizeof(ptr) gives the size of the pointer itself, not what it points to.
To get the number of elements in an array: sizeof(arr) / sizeof(arr[0]).
VLAs (C99) are the one exception: sizeof is evaluated at runtime for VLAs.

Pseudo Code

1. sizeof(type) -> size in bytes of that type
2. sizeof(expression) -> size of expression's type (expression not evaluated)
3. sizeof(array) -> total bytes of the entire array
4. sizeof(pointer) -> size of the pointer (4 or 8 bytes), NOT what it points to
5. Number of elements = sizeof(arr) / sizeof(arr[0])

Code

#include <stdio.h>

int main(void) {
    int arr[10];
    int *ptr = arr;

    printf("sizeof(int):    %zu\n", sizeof(int));       /* 4 */
    printf("sizeof(arr):    %zu\n", sizeof(arr));       /* 40 (10 * 4) */
    printf("sizeof(ptr):    %zu\n", sizeof(ptr));       /* 8 on 64-bit */
    printf("elements:       %zu\n", sizeof(arr) / sizeof(arr[0])); /* 10 */

    /* sizeof does NOT evaluate its operand */
    int x = 5;
    printf("sizeof(x++):    %zu\n", sizeof(x++)); /* 4 */
    printf("x is still:     %d\n", x);            /* 5, not 6! */

    return 0;
}

sizeof(int):    4
sizeof(arr):    40
sizeof(ptr):    8
elements:       10
sizeof(x++):    4
x is still:     5

Key Points

•sizeof is a compile-time operator (except for VLAs in C99)
•Returns size_t, use %zu to print
•sizeof(array) gives total byte size; sizeof(pointer) gives pointer size
•The classic idiom for array length: sizeof(arr)/sizeof(arr[0])
•sizeof does NOT evaluate its operand

Gotchas

•sizeof(pointer) returns the pointer size (4 or 8), not the size of the pointed-to data
•When an array is passed to a function, it decays to a pointer, so sizeof gives pointer size
•sizeof(x++) does NOT increment x -- the expression is not evaluated
•sizeof('a') is sizeof(int) in C (not 1), because character literals are int in C

sizeof returns the byte size of a type or expression at compile time. For arrays it gives the total byte count; for pointers it gives the pointer size (not the data size). Use sizeof(arr)/sizeof(arr[0]) to get the element count.

•Compile-time operator (except VLAs)
•sizeof(arr)/sizeof(arr[0]) gives element count

#include <stdio.h>
int main(void) {
    int arr[5];
    printf("Total: %zu, Count: %zu\n",
           sizeof(arr),
           sizeof(arr) / sizeof(arr[0]));
    return 0;
}

Total: 20, Count: 5

After passing an array to a function, sizeof gives pointer size, not array size

Question 3 / 15

What is the difference between signed and unsigned integers? What happens on overflow?

Signed integers can represent negative, zero, and positive values. The most significant bit (MSB) is the sign bit. Most systems use two's complement representation.

Unsigned integers can only represent non-negative values, effectively doubling the positive range.

For a 32-bit integer:

signed int: -2,147,483,648 to 2,147,483,647
unsigned int: 0 to 4,294,967,295

Overflow behavior:

Signed overflow is undefined behavior (UB) in C. The compiler can assume it never happens, which can lead to surprising optimizations (e.g., removing checks).
Unsigned overflow is well-defined: it wraps around modulo 2^N. For example, UINT_MAX + 1 == 0.

This distinction is critical: signed overflow is a bug that the compiler is free to exploit. Unsigned overflow is a feature you can rely on.

Pseudo Code

1. signed int: uses MSB as sign bit, range [-2^(N-1), 2^(N-1)-1]
2. unsigned int: all bits for magnitude, range [0, 2^N - 1]
3. Signed overflow: UNDEFINED BEHAVIOR (compiler can do anything)
4. Unsigned overflow: wraps around modulo 2^N (well-defined)

Code

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

int main(void) {
    /* Unsigned wrap-around: well-defined */
    unsigned int u = UINT_MAX;
    printf("UINT_MAX:     %u\n", u);       /* 4294967295 */
    printf("UINT_MAX + 1: %u\n", u + 1);   /* 0 (wraps) */

    /* Signed overflow: UNDEFINED BEHAVIOR -- do NOT rely on this */
    /* The following line is technically UB, shown for illustration only */
    /* int s = INT_MAX;
       printf("%d\n", s + 1);  // UB! Could print anything */

    /* Safe signed overflow check */
    int a = INT_MAX;
    int b = 1;
    if (b > 0 && a > INT_MAX - b) {
        printf("Would overflow!\n");
    }

    /* Mixing signed and unsigned */
    int neg = -1;
    unsigned int pos = 1;
    if (neg < pos) {
        printf("Expected: -1 < 1\n");
    } else {
        printf("Surprise: -1 is converted to unsigned!\n");
    }
    /* Prints: Surprise: -1 is converted to unsigned! */
    /* Because -1 becomes UINT_MAX (4294967295) when converted to unsigned */

    return 0;
}

UINT_MAX:     4294967295
UINT_MAX + 1: 0
Would overflow!
Surprise: -1 is converted to unsigned!

Key Points

•Signed overflow is undefined behavior in C
•Unsigned overflow wraps around modulo 2^N (well-defined)
•Most systems use two's complement for signed integers
•The compiler can optimize assuming signed overflow never happens
•Check for overflow BEFORE it happens, not after

Gotchas

•Comparing signed and unsigned values causes implicit conversion to unsigned: -1 > 1u is TRUE
•Signed overflow being UB means the compiler can remove your overflow check entirely
•for (unsigned i = n; i >= 0; i--) is an infinite loop because unsigned is always >= 0
•Mixing signed and unsigned in arithmetic silently converts signed to unsigned

Signed integers have a sign bit and can be negative. Unsigned integers use all bits for magnitude. Signed overflow is undefined behavior; unsigned overflow wraps modulo 2^N. Never mix signed and unsigned in comparisons.

•Signed overflow = UB; unsigned overflow = well-defined wrap
•Never compare signed with unsigned directly

#include <stdio.h>
#include <limits.h>
int main(void) {
    unsigned int u = UINT_MAX;
    printf("%u + 1 = %u\n", u, u + 1); /* 0, wraps */
    /* signed overflow is UB -- never rely on it */
    return 0;
}

4294967295 + 1 = 0

-1 > 1u evaluates to TRUE because -1 converts to UINT_MAX

Question 4 / 15

What are storage classes in C (auto, static, extern, register)?

Storage classes determine the scope, lifetime, and linkage of a variable.

1. auto (default for local variables)

Scope: block scope
Lifetime: created when block is entered, destroyed when exited
Linkage: none
Rarely written explicitly (it is the default)

2. static

On a local variable: keeps its value between function calls (lifetime = entire program), but scope remains block-local.
On a global variable/function: restricts linkage to the current translation unit (internal linkage). This is the C way of making things "private" to a file.

3. extern

Declares a variable/function that is defined elsewhere (another translation unit).
Does NOT allocate storage -- just says "this exists somewhere."
Global variables have external linkage by default; extern makes the declaration explicit.

4. register

Suggests to the compiler to store the variable in a CPU register for faster access.
You cannot take the address of a register variable (&var is illegal).
Modern compilers ignore this hint and optimize register allocation themselves.

Pseudo Code

1. auto: default local, block scope, block lifetime, no linkage
2. static local: block scope, program lifetime, no linkage
3. static global/function: file scope, program lifetime, internal linkage
4. extern: declaration only, external linkage, defined elsewhere
5. register: hint for CPU register, cannot take address

Code

#include <stdio.h>

/* extern declaration: defined in another file (or below) */
extern int global_count;

/* static global: only visible in this file */
static int file_private = 100;

void counter(void) {
    /* static local: persists between calls */
    static int count = 0;
    count++;
    printf("count = %d\n", count);
}

int global_count = 42; /* actual definition */

int main(void) {
    auto int x = 10; /* auto is default, rarely written */
    register int i;  /* hint to use register */

    counter(); /* count = 1 */
    counter(); /* count = 2 */
    counter(); /* count = 3 */

    printf("global_count = %d\n", global_count); /* 42 */
    printf("file_private = %d\n", file_private); /* 100 */

    /* &i would be illegal if compiler honors register */
    (void)x;
    (void)i;
    return 0;
}

count = 1
count = 2
count = 3
global_count = 42
file_private = 100

Key Points

•auto is the default for local variables -- rarely written explicitly
•static on local variable: value persists across calls
•static on global/function: restricts visibility to current file
•extern declares a variable defined in another translation unit
•register is a hint; modern compilers ignore it

Gotchas

•static local variables are initialized only ONCE, not on every function call
•static locals are initialized to 0 by default (unlike auto locals which are uninitialized)
•You cannot take the address of a register variable
•extern on a local variable is legal but confusing -- avoid it

auto: default local (block scope/lifetime). static on local: persists between calls. static on global/function: file-private. extern: declares variable defined elsewhere. register: obsolete hint for CPU register.

•static local = persistent value; static global = file-private
•extern = declaration only, no storage allocated

#include <stdio.h>
void counter(void) {
    static int n = 0; /* persists between calls */
    n++;
    printf("%d\n", n);
}
int main(void) {
    counter(); /* 1 */
    counter(); /* 2 */
    return 0;
}

1
2

static locals are initialized once, not on every call

Question 5 / 15

How does the const qualifier work in C?

const makes a variable read-only after initialization. It does NOT make it a compile-time constant (unlike C++ constexpr).

Key distinctions:

const int x = 10; -- x cannot be modified after initialization.
const variables in C are NOT true compile-time constants. You cannot use them as array sizes in C89 (you can in C99 with VLAs, but that is a different feature).
A const variable can be modified through a pointer cast (undefined behavior, but technically possible).
const with pointers has different meanings depending on placement (covered in pointers topic).

const vs #define:

const variables have a type and obey scope rules.
#define is a textual replacement with no type checking and no scope.
Prefer const for typed constants; use #define or enum for compile-time integer constants.

const in function parameters:

void f(const int *p) promises the function will not modify *p through this pointer.
This is a contract with the caller.

Pseudo Code

1. const int x = 10;  // x is read-only
2. x = 20;           // ERROR: cannot modify const
3. const is NOT a compile-time constant in C (unlike #define)
4. const in parameters = promise not to modify
5. Prefer const over #define for type safety

Code

#include <stdio.h>

void print_array(const int *arr, int size) {
    /* arr[0] = 99;  // ERROR: cannot modify through const pointer */
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    const int MAX = 100;
    /* MAX = 200;  // ERROR: assignment of read-only variable */

    printf("MAX = %d\n", MAX);

    /* const is NOT a compile-time constant in C89 */
    /* const int SIZE = 5;
       int arr[SIZE];  // Only valid in C99+ (VLA), not C89 */

    /* Use enum for compile-time integer constants */
    enum { BUFFER_SIZE = 256 };
    char buffer[BUFFER_SIZE]; /* Always valid */

    int data[] = {1, 2, 3, 4, 5};
    print_array(data, 5);

    (void)buffer;
    return 0;
}

MAX = 100
1 2 3 4 5

Key Points

•const makes a variable read-only, not a compile-time constant
•const variables have proper type and scope, unlike #define
•Use const in function parameters to indicate read-only access
•Use enum for true compile-time integer constants in C
•const helps catch accidental modification bugs

Gotchas

•const int x = 5; does NOT create a compile-time constant in C (unlike C++)
•You cannot use a const variable as an array size in C89 (use enum or #define instead)
•Casting away const and modifying the value is undefined behavior
•const applies to the variable, not the value -- another pointer can still modify the data

const makes a variable read-only after initialization. It is NOT a compile-time constant in C. Use enum or #define for true compile-time constants. Use const in function parameters to promise you will not modify the data.

•const = read-only, not compile-time constant
•Use enum for compile-time integer constants

#include <stdio.h>
int main(void) {
    const int MAX = 100;
    /* MAX = 200; // ERROR */
    enum { BUF_SIZE = 256 }; /* true compile-time constant */
    char buf[BUF_SIZE];
    printf("%d\n", MAX);
    (void)buf;
    return 0;
}

const int N = 5; int arr[N]; is a VLA in C99, not a fixed-size array

Question 6 / 15

What is typedef and how is it used?

typedef creates an alias (alternate name) for an existing type. It does NOT create a new type -- it is purely a naming convenience.

Common uses:

Simplify complex type declarations (function pointers, structs).
Improve code portability (typedef unsigned long size_type;).
Make struct usage cleaner (typedef struct { ... } Point;).
Create platform-independent integer types (like uint32_t from <stdint.h>, which is implemented using typedef).

typedef vs #define:

typedef is handled by the compiler and respects scope.
#define is handled by the preprocessor and has no scope.
typedef handles pointer types correctly; #define can fail.

Pseudo Code

1. typedef existing_type new_name;
2. typedef unsigned long ulong;
3. typedef struct { int x; int y; } Point;
4. typedef int (*FuncPtr)(int, int);  // function pointer alias
5. typedef is a compiler feature; #define is preprocessor text substitution

Code

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

/* Simple alias */
typedef unsigned long ulong;

/* Struct typedef */
typedef struct {
    int x;
    int y;
} Point;

/* Function pointer typedef */
typedef int (*MathFunc)(int, int);

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

int main(void) {
    ulong count = 1000000UL;
    printf("count = %lu\n", count);

    Point p = {10, 20};
    printf("Point(%d, %d)\n", p.x, p.y);

    MathFunc op = add;
    printf("add(3, 4) = %d\n", op(3, 4));
    op = mul;
    printf("mul(3, 4) = %d\n", op(3, 4));

    /* stdint.h uses typedef internally */
    uint32_t val = 42;
    printf("uint32_t: %u\n", val);

    return 0;
}

count = 1000000
Point(10, 20)
add(3, 4) = 7
mul(3, 4) = 12
uint32_t: 42

Key Points

•typedef creates an alias, not a new type
•Makes complex declarations (function pointers, structs) readable
•Handled by the compiler, respects scope rules
•stdint.h types (uint32_t etc.) are implemented using typedef
•typedef is preferred over #define for type aliases

Gotchas

•typedef does NOT create a new distinct type -- you can mix the alias with the original freely
•#define PTR int* then PTR a, b; makes a a pointer but b a plain int. typedef avoids this.
•typedef names share the same namespace as variable names in C
•Overusing typedef can hide important pointer/const information (e.g., hiding that a type is a pointer)

typedef creates an alias for an existing type. It does not create a new type. Use it to simplify struct declarations, function pointers, and platform-independent types.

•typedef = alias, not a new type
•Prefer typedef over #define for type names

#include <stdio.h>
typedef struct { int x; int y; } Point;
typedef int (*BinOp)(int, int);
int add(int a, int b) { return a + b; }
int main(void) {
    Point p = {1, 2};
    BinOp op = add;
    printf("%d\n", op(p.x, p.y));
    return 0;
}

#define PTR int* makes PTR a, b; declare a as pointer but b as int

Question 7 / 15

What are type qualifiers in C (const, volatile, restrict)?

C has three type qualifiers that modify how variables can be accessed:

1. const -- the variable is read-only after initialization.

2. volatile -- tells the compiler that the variable's value may change at any time (by hardware, another thread, or signal handler). The compiler must not optimize away reads/writes to this variable.

3. restrict (C99) -- a pointer qualifier that tells the compiler this pointer is the only way to access the data it points to. This allows the compiler to perform aggressive optimizations.

Qualifiers can be combined: const volatile int status; means the program cannot modify it, but it can change externally (e.g., a hardware read-only status register).

restrict example: memcpy(restrict dest, restrict src, n) tells the compiler that dest and src do not overlap, allowing it to optimize the copy.

Pseudo Code

1. const: read-only, compiler prevents writes
2. volatile: no optimization on reads/writes, value may change externally
3. restrict (C99): pointer is the sole access path, enables optimizations
4. Combine: const volatile = externally changing read-only value
5. restrict is a promise from programmer to compiler

Code

#include <stdio.h>
#include <string.h>

/* volatile: compiler must re-read every time */
volatile int hardware_reg = 0;

/* restrict: promise no aliasing (C99) */
void fast_copy(int * restrict dest, const int * restrict src, int n) {
    for (int i = 0; i < n; i++) {
        dest[i] = src[i];
    }
}

int main(void) {
    /* const: read-only */
    const int MAX = 100;
    printf("MAX = %d\n", MAX);

    /* volatile: compiler will not cache this in a register */
    volatile int sensor = 42;
    int val = sensor;  /* must read from memory each time */
    printf("sensor = %d\n", val);

    /* restrict usage */
    int a[] = {1, 2, 3};
    int b[3];
    fast_copy(b, a, 3);
    printf("b[0]=%d, b[1]=%d, b[2]=%d\n", b[0], b[1], b[2]);

    return 0;
}

MAX = 100
sensor = 42
b[0]=1, b[1]=2, b[2]=3

Key Points

•const prevents modification; volatile prevents optimization; restrict enables optimization
•volatile is essential for hardware registers, signal handlers, and memory-mapped I/O
•restrict is a promise by the programmer -- violating it is undefined behavior
•const volatile makes sense: value changes externally but program cannot write it
•restrict only applies to pointers

Gotchas

•volatile does NOT make operations atomic -- it only prevents caching/reordering by the compiler
•Forgetting volatile on hardware registers can cause the compiler to optimize away necessary reads
•Violating a restrict promise (aliasing two restrict pointers) is undefined behavior
•volatile is not sufficient for thread safety -- use atomics or mutexes

const = read-only. volatile = do not optimize away reads/writes. restrict (C99) = this pointer is the only access path. They can combine: const volatile for externally-changing read-only data.

•volatile = no caching; restrict = no aliasing; const = no writing
•volatile is NOT sufficient for thread safety

#include <stdio.h>
volatile int hw_reg = 0; /* compiler must re-read every time */
void copy(int * restrict dst, const int * restrict src, int n) {
    for (int i = 0; i < n; i++) dst[i] = src[i];
}
int main(void) {
    int a[] = {1,2,3}, b[3];
    copy(b, a, 3);
    printf("%d %d %d\n", b[0], b[1], b[2]);
    return 0;
}

1 2 3

volatile does not provide atomicity -- use stdatomic.h for threads

Question 8 / 15

How do integer promotions work in C?

Integer promotion is the automatic conversion of small integer types to int (or unsigned int) when used in expressions.

The rule: Any value of type char, short, bit-field, or their signed/unsigned variants is promoted to int if int can represent all values of the original type, otherwise to unsigned int. This happens BEFORE any arithmetic operation.

Why? The CPU typically operates on int-sized operands. Promoting smaller types avoids truncation during intermediate calculations.

Usual arithmetic conversions (when two different types are in an expression):

If either operand is long double, the other is converted to long double.
If either is double, the other converts to double.
If either is float, the other converts to float.
Integer promotions are applied, then: if one is unsigned long, both become unsigned long, etc.

Pseudo Code

1. char/short values are promoted to int before arithmetic
2. If int can hold all values -> promote to int
3. Otherwise -> promote to unsigned int
4. Then: usual arithmetic conversions apply for mixed types
5. Result type = the 'wider' of the two operand types

Code

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a and b are promoted to int before multiplication */
    int result = a * b;  /* 10000, not overflow */
    printf("char * char = %d\n", result); /* 10000 */

    /* Without promotion, 100 * 100 = 10000 would overflow char (max 127) */

    /* Surprising case with unsigned char */
    unsigned char uc = 255;
    /* uc is promoted to int (255), then negated */
    if (-uc < 0) {
        printf("-uc is negative (promoted to int)\n"); /* This prints */
    }

    /* Shift operators: left operand is promoted */
    unsigned char mask = 0xFF;
    /* mask is promoted to int before shift */
    int shifted = mask << 24;
    printf("shifted = 0x%X\n", shifted); /* 0xFF000000 */

    /* sizeof promotion result */
    printf("sizeof(char + char) = %zu\n",
           sizeof(a + b)); /* sizeof(int), typically 4 */

    return 0;
}

char * char = 10000
-uc is negative (promoted to int)
shifted = 0xFF000000
sizeof(char + char) = 4

Key Points

•char and short are always promoted to int in expressions
•Promotion prevents overflow in intermediate calculations
•sizeof(char_expr + char_expr) is sizeof(int), not sizeof(char)
•Usual arithmetic conversions then apply for mixed-type operations
•Integer promotions happen implicitly -- you cannot prevent them

Gotchas

•char a = 0xFF; if (a == 0xFF) can be FALSE if char is signed (a promoted to -1)
•Promotions can change the sign: unsigned char 255 promotes to int 255 (positive)
•Bitwise NOT on unsigned char: ~uc promotes to int first, result has high bits set
•The result of arithmetic on chars/shorts is always int, never char/short

char and short are automatically promoted to int before any arithmetic. This prevents overflow in intermediate calculations. The promoted result is always at least int-sized.

•char and short promote to int before arithmetic
•Prevents intermediate overflow in calculations

#include <stdio.h>
int main(void) {
    char a = 100, b = 100;
    printf("%d\n", a * b);          /* 10000, not overflow */
    printf("%zu\n", sizeof(a + b)); /* sizeof(int) = 4 */
    return 0;
}

10000
4

~(unsigned char)0xFF becomes 0xFFFFFF00 (int), not 0x00

Question 9 / 15

What are the precision issues with floating-point numbers in C?

Floating-point numbers in C follow the IEEE 754 standard. They represent real numbers in binary, which means many decimal fractions cannot be represented exactly.

Key issues:

Representation error: 0.1 in decimal is a repeating fraction in binary, so 0.1 + 0.2 != 0.3 exactly.
Precision limits: float has ~7 significant digits; double has ~15.
Comparison: Never compare floats with ==. Use an epsilon-based comparison.
Accumulation: Repeated operations accumulate rounding errors.
Large + small: Adding a very small number to a very large number can lose the small number entirely (catastrophic cancellation).

Special values:

+inf, -inf (overflow result)
NaN (Not a Number: 0.0/0.0, sqrt(-1))
NaN != NaN (a NaN is not equal to anything, including itself)

Pseudo Code

1. 0.1 + 0.2 != 0.3 due to binary representation
2. Never use == for float comparison
3. Use fabs(a - b) < epsilon instead
4. float: ~7 digits; double: ~15 digits
5. NaN != NaN (use isnan() to check)
6. Large + tiny can lose the tiny value

Code

#include <stdio.h>
#include <math.h>
#include <float.h>

int main(void) {
    /* Representation error */
    double a = 0.1 + 0.2;
    printf("0.1 + 0.2 = %.20f\n", a); /* 0.30000000000000004... */
    printf("== 0.3? %d\n", a == 0.3); /* 0 (false!) */

    /* Epsilon comparison */
    double eps = 1e-9;
    if (fabs(a - 0.3) < eps) {
        printf("Approximately equal\n"); /* This prints */
    }

    /* Precision limits */
    float f = 16777216.0f;  /* 2^24 */
    printf("f     = %.1f\n", f);       /* 16777216.0 */
    printf("f + 1 = %.1f\n", f + 1.0f); /* 16777216.0! Lost precision */

    /* Special values */
    double inf = 1.0 / 0.0;
    double nan = 0.0 / 0.0;
    printf("1/0 = %f\n", inf);    /* inf */
    printf("0/0 = %f\n", nan);    /* nan or -nan */
    printf("nan == nan? %d\n", nan == nan); /* 0 (false!) */
    printf("isnan(nan)? %d\n", isnan(nan)); /* 1 (true) */

    return 0;
}

0.1 + 0.2 = 0.30000000000000004441
== 0.3? 0
Approximately equal
f     = 16777216.0
f + 1 = 16777216.0
1/0 = inf
0/0 = nan
nan == nan? 0
isnan(nan)? 1

Key Points

•0.1 + 0.2 != 0.3 due to binary floating-point representation
•Never compare floats with == ; use epsilon-based comparison
•float has ~7 significant digits; double has ~15
•NaN is not equal to anything, including itself
•Use isnan() and isinf() from <math.h> to check special values

Gotchas

•float literals like 0.1 are actually double; use 0.1f for float
•printf("%f", float_val) promotes float to double (variadic function rule)
•Accumulated rounding errors in loops can produce wildly wrong results
•Comparing floats with == passes sometimes and fails unpredictably -- always use epsilon

Floats are binary approximations -- 0.1 + 0.2 != 0.3. Never use == for comparison; use fabs(a - b) < epsilon. float gives ~7 digits precision, double ~15. NaN != NaN.

•Never compare floats with ==
•Use fabs(a - b) < epsilon

#include <stdio.h>
#include <math.h>
int main(void) {
    double a = 0.1 + 0.2;
    printf("%d\n", a == 0.3);         /* 0 (false) */
    printf("%d\n", fabs(a - 0.3) < 1e-9); /* 1 (true) */
    return 0;
}

0
1

0.1 + 0.2 is 0.30000000000000004, not exactly 0.3

Question 10 / 15

How is char used as an integer type in C?

In C, char is fundamentally an integer type that happens to be used for characters. Every char holds a numeric value, and character literals like 'A' are actually integers.

Key facts:

'A' has the integer value 65 (ASCII).
You can perform arithmetic on chars: 'A' + 1 gives 66 (which is 'B').
char is 1 byte, but character literals ('A') have type int in C (not char!).
There are three distinct char types: char, signed char, unsigned char. Plain char may be signed or unsigned (implementation-defined).

Common patterns:

Convert digit char to int: ch - '0' (works because '0' through '9' are contiguous in ASCII)
Convert lowercase to uppercase: ch - 32 or ch - ('a' - 'A')
Check ranges: if (ch >= 'a' && ch <= 'z') to test for lowercase

Pseudo Code

1. char is a small integer type (1 byte)
2. 'A' == 65, 'a' == 97, '0' == 48 (ASCII)
3. Character arithmetic: 'A' + 1 == 'B'
4. Digit to number: ch - '0'
5. Case conversion: ch - 32 or ch + 32
6. Character literals have type int in C (not char)

Code

#include <stdio.h>

int main(void) {
    char ch = 'A';
    printf("'A' as int: %d\n", ch);      /* 65 */
    printf("'A' + 1 = '%c'\n", ch + 1);  /* 'B' */

    /* Digit character to integer */
    char digit = '7';
    int num = digit - '0';  /* 55 - 48 = 7 */
    printf("'%c' -> %d\n", digit, num);

    /* Case conversion */
    char lower = 'a';
    char upper = lower - ('a' - 'A');  /* 97 - 32 = 65 = 'A' */
    printf("'%c' -> '%c'\n", lower, upper);

    /* Character literal is actually int in C */
    printf("sizeof('A') = %zu\n", sizeof('A'));  /* 4 (sizeof int!) */
    printf("sizeof(ch)  = %zu\n", sizeof(ch));   /* 1 (sizeof char) */

    /* Loop through alphabet */
    for (char c = 'a'; c <= 'z'; c++) {
        printf("%c", c);
    }
    printf("\n");

    return 0;
}

'A' as int: 65
'A' + 1 = 'B'
'7' -> 7
'a' -> 'A'
sizeof('A') = 4
sizeof(ch)  = 1
abcdefghijklmnopqrstuvwxyz

Key Points

•char is a 1-byte integer type, not a special character type
•Character literals ('A') have type int in C, not char
•Digit to number: ch - '0'; lowercase to uppercase: ch - 32
•ASCII digits 0-9 are contiguous (48-57), as are letters A-Z and a-z
•Three distinct types: char, signed char, unsigned char

Gotchas

•sizeof('A') is sizeof(int) in C, but sizeof(char) in C++
•Plain char may be signed or unsigned -- do not assume either for portable code
•EOF is typically -1, so use int (not char) for getchar() return value
•ch - '0' only works for single digits; multi-digit conversion needs atoi() or strtol()

char is a 1-byte integer. 'A' is 65, '0' is 48. You can do arithmetic: ch - '0' converts a digit char to int, ch - 32 converts lowercase to uppercase. Character literals have type int in C.

•char is an integer type; 'A' == 65
•ch - '0' converts digit char to number

#include <stdio.h>
int main(void) {
    char ch = '7';
    int n = ch - '0'; /* 7 */
    printf("'%c' = %d\n", ch, n);
    printf("sizeof('A') = %zu\n", sizeof('A')); /* 4, not 1 */
    return 0;
}

'7' = 7
sizeof('A') = 4

sizeof('A') is sizeof(int) in C, not 1

Question 11 / 15

What is a void pointer and what are its basic uses?

A void * (void pointer) is a generic pointer that can point to any data type. It is C's mechanism for writing type-generic code.

Key properties:

Any pointer can be implicitly converted to void * and back (without a cast in C).
You CANNOT dereference a void * directly -- you must cast it to a typed pointer first.
You CANNOT perform pointer arithmetic on void * in standard C (GNU C allows it as an extension, treating it like char *).
sizeof(void) is undefined in standard C (GNU extension defines it as 1).

Common uses:

malloc() returns void * -- works with any type.
Generic functions like qsort() and bsearch() accept void * parameters.
Callback data parameters (passing arbitrary user data).
Generic data structures (linked list of any type).

Pseudo Code

1. void *ptr can point to any type
2. Cannot dereference void * directly -- must cast first
3. Cannot do arithmetic on void * (standard C)
4. Any pointer -> void * conversion is implicit (no cast needed)
5. void * -> typed pointer: implicit in C, needs cast in C++

Code

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

void print_value(void *ptr, char type) {
    switch (type) {
        case 'i': printf("%d\n", *(int *)ptr); break;
        case 'f': printf("%f\n", *(float *)ptr); break;
        case 'c': printf("%c\n", *(char *)ptr); break;
    }
}

int main(void) {
    int x = 42;
    float f = 3.14f;
    char c = 'A';

    void *ptr;

    /* Any pointer converts to void * implicitly */
    ptr = &x;
    print_value(ptr, 'i'); /* 42 */

    ptr = &f;
    print_value(ptr, 'f'); /* 3.140000 */

    ptr = &c;
    print_value(ptr, 'c'); /* A */

    /* malloc returns void * -- no cast needed in C */
    int *arr = malloc(5 * sizeof(int));
    if (arr) {
        arr[0] = 10;
        printf("arr[0] = %d\n", arr[0]);
        free(arr);
    }

    return 0;
}

42
3.140000
A
arr[0] = 10

Key Points

•void * is a generic pointer that can point to any data type
•Must cast to a typed pointer before dereferencing
•malloc() returns void * -- no cast needed in C
•Standard library functions like qsort() use void * for genericity
•void * -> typed pointer is implicit in C but requires a cast in C++

Gotchas

•Casting void * to the wrong type and dereferencing is undefined behavior
•Pointer arithmetic on void * is not allowed in standard C (only as GNU extension)
•Do NOT cast the return value of malloc() in C -- it can hide missing #include <stdlib.h>
•Storing type information alongside void * is your responsibility -- C has no runtime type checking

void * is a generic pointer that can point to any type. You must cast it before dereferencing. malloc() returns void *. Standard C does not allow pointer arithmetic on void *.

•void * can point to any type, must cast to dereference
•malloc returns void * -- no cast needed in C

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int x = 42;
    void *ptr = &x;  /* implicit conversion */
    printf("%d\n", *(int *)ptr); /* must cast to dereference */
    int *arr = malloc(5 * sizeof(int)); /* no cast needed in C */
    free(arr);
    return 0;
}

Casting void * to the wrong type is undefined behavior

Question 12 / 15

What are the rules for variable initialization in C?

C has different initialization rules depending on storage duration:

1. Global (static storage duration):

Automatically initialized to zero/null if not explicitly initialized.
Initialized before main() runs.
Initializer must be a compile-time constant expression.

2. Local (automatic storage duration):

NOT automatically initialized -- they contain garbage (indeterminate values).
Reading an uninitialized local variable is undefined behavior.
Can be initialized with any expression (not just constants).

3. Static locals:

Initialized to zero by default (like globals).
Initializer must be a compile-time constant.
Initialization happens once, before first use.

4. Arrays:

Partial initialization: remaining elements are zero-initialized.
int arr[5] = {1, 2} gives {1, 2, 0, 0, 0}.
int arr[5] = {0} zero-initializes the entire array.

5. Structs:

Same rules as arrays: partial initialization zero-fills the rest.
struct s x = {0} zero-initializes all members.

Pseudo Code

1. Global/static: auto-initialized to zero if not explicit
2. Local (auto): NOT initialized, contains garbage
3. Reading uninitialized local = undefined behavior
4. Partial array init: rest is zero-filled
5. int arr[N] = {0}; // zero-initialize entire array
6. struct s x = {0}; // zero-initialize all members

Code

#include <stdio.h>

int global_var;           /* automatically zero */
static int static_var;    /* automatically zero */

int main(void) {
    int local_var;  /* UNINITIALIZED -- garbage value */
    /* printf("%d", local_var);  // UB: reading uninitialized variable */

    static int s_local; /* automatically zero */
    printf("global_var = %d\n", global_var);  /* 0 */
    printf("static_var = %d\n", static_var);  /* 0 */
    printf("s_local    = %d\n", s_local);     /* 0 */

    /* Partial initialization -- rest is zero */
    int arr[5] = {1, 2};
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }
    /* Output: 1, 2, 0, 0, 0 */

    /* Zero-initialize entire array */
    int zeros[5] = {0};
    printf("zeros[3] = %d\n", zeros[3]); /* 0 */

    /* Designated initializers (C99) */
    int d[5] = {[2] = 42, [4] = 99};
    /* d = {0, 0, 42, 0, 99} */
    printf("d[2]=%d d[4]=%d\n", d[2], d[4]);

    return 0;
}

global_var = 0
static_var = 0
s_local    = 0
arr[0] = 1
arr[1] = 2
arr[2] = 0
arr[3] = 0
arr[4] = 0
zeros[3] = 0
d[2]=42 d[4]=99

Key Points

•Global and static variables are auto-initialized to zero
•Local variables are NOT initialized -- they contain garbage
•Reading an uninitialized variable is undefined behavior
•Partial initialization zero-fills remaining elements
•Use = {0} to zero-initialize arrays and structs

Gotchas

•Reading an uninitialized local is UB -- it might seem to work but can break with optimization
•int arr[100] = {0}; is NOT the same as memset(arr, 0, sizeof(arr)) for floating-point (0 bits vs 0.0)
•Global initializers must be compile-time constants: int g = rand(); is illegal
•static int x = func(); is illegal -- initializer must be constant for static variables

Globals and statics are auto-initialized to zero. Locals are NOT initialized (garbage). Reading an uninitialized local is undefined behavior. Partial array init zero-fills the rest. Use = {0} to zero-initialize.

•Globals/statics = zero; locals = garbage
•= {0} zero-initializes arrays and structs

#include <stdio.h>
int g; /* auto-initialized to 0 */
int main(void) {
    int local; /* garbage -- do not read! */
    int arr[5] = {1, 2}; /* {1, 2, 0, 0, 0} */
    static int s; /* 0 */
    printf("g=%d s=%d arr[4]=%d\n", g, s, arr[4]);
    (void)local;
    return 0;
}

g=0 s=0 arr[4]=0

Reading an uninitialized local is UB, even if it seems to work

Question 13 / 15

What is the difference between scope and lifetime of a variable?

Scope = where in the source code a variable name is visible (can be referenced).

Lifetime (storage duration) = the period during which the variable's memory exists.

These are independent concepts:

Scope types:

Block scope: from declaration to end of enclosing {} block.
File scope: from declaration to end of the file (global variables).
Function scope: only applies to goto labels.
Function prototype scope: parameters in a prototype declaration.

Lifetime types:

Automatic: created on block entry, destroyed on block exit (local variables).
Static: exists for the entire program duration (globals, static locals).
Allocated: exists from malloc() until free() (heap memory).

The critical case: static local variables:

Scope: block (only visible inside the function).
Lifetime: the entire program (value persists between calls).
This shows scope and lifetime are independent.

Pseudo Code

Scope: where the name is visible
Lifetime: how long the memory exists

Local variable: block scope, automatic lifetime
Global variable: file scope, static lifetime
static local: block scope, static lifetime
malloc'd memory: no scope (accessed via pointer), allocated lifetime

Code

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

int global = 10;  /* file scope, static lifetime */

void demo(void) {
    int local = 1;          /* block scope, auto lifetime */
    static int persist = 0; /* block scope, static lifetime */
    persist++;
    printf("local=%d persist=%d\n", local, persist);
}

int main(void) {
    demo(); /* local=1 persist=1 */
    demo(); /* local=1 persist=2 */
    demo(); /* local=1 persist=3 */
    /* local is recreated each call; persist survives */

    /* Block scope example */
    {
        int x = 42;
        printf("x = %d\n", x); /* 42 */
    }
    /* x is no longer visible here */
    /* printf("%d", x); // ERROR: x undeclared */

    /* Heap: lifetime controlled by programmer */
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("heap = %d\n", *p);
    free(p); /* lifetime ends here */

    return 0;
}

local=1 persist=1
local=1 persist=2
local=1 persist=3
x = 42
heap = 99

Key Points

•Scope = visibility of the name; lifetime = duration of the memory
•They are independent: static local has block scope but program-long lifetime
•Local variables: block scope, automatic lifetime
•Global variables: file scope, static lifetime
•Heap memory has no scope -- accessed only via pointers

Gotchas

•Returning a pointer to a local variable is a bug: the lifetime ends but the pointer remains
•A variable can exist (lifetime) but be inaccessible (out of scope) -- like a static local between calls
•Heap memory has no automatic cleanup -- forgetting free() causes memory leaks
•Shadowing: an inner scope can declare a variable with the same name as an outer one

Scope = where the name is visible. Lifetime = how long the memory exists. A static local has block scope but program lifetime, showing they are independent. Locals die at block exit; globals and statics live for the whole program.

•Scope = visibility; lifetime = memory duration
•static local: block scope + program lifetime

#include <stdio.h>
void count(void) {
    static int n = 0; /* block scope, program lifetime */
    n++;
    printf("%d\n", n);
}
int main(void) {
    count(); /* 1 */
    count(); /* 2 */
    /* n is not visible here, but it still exists */
    return 0;
}

1
2

Returning a pointer to a local variable is a dangling pointer bug

Question 14 / 15

What is linkage in C (internal vs external)?

Linkage determines whether the same name in different translation units (source files) refers to the same entity.

Three kinds of linkage:

External linkage: the name can be referenced from other translation units. Global variables and functions have external linkage by default.
Internal linkage: the name is only visible within its translation unit. Achieved by using the static keyword on file-scope variables or functions.
No linkage: the name is unique to its scope. Block-scope variables (local variables) have no linkage.

How it works in practice:

File A defines int count = 0; (external linkage).
File B declares extern int count; (refers to the same count).
File C has static int count = 0; (internal linkage -- its own private count).

Why it matters:

Use static on file-scope functions/variables to make them file-private (encapsulation).
Use extern to share variables across files.
Internal linkage avoids name collisions between files.

Pseudo Code

1. External linkage (default for globals): visible across files
2. Internal linkage (static at file scope): visible only in current file
3. No linkage (local variables): visible only in current block
4. extern keyword: declares a variable defined in another file
5. static at file scope: restricts to internal linkage

Code

/* === file: counter.c === */
#include <stdio.h>

/* Internal linkage: only visible in this file */
static int internal_count = 0;

/* External linkage: visible from other files */
int public_count = 0;

/* Internal linkage function: file-private helper */
static void increment_internal(void) {
    internal_count++;
}

/* External linkage function: public API */
void increment_public(void) {
    increment_internal();
    public_count++;
    printf("internal=%d public=%d\n", internal_count, public_count);
}

/* === file: main.c === */
/* extern int public_count;    // refers to counter.c's public_count */
/* extern void increment_public(void); // function declaration */
/* static int internal_count; // our own, separate from counter.c's */

int main(void) {
    increment_public(); /* internal=1 public=1 */
    increment_public(); /* internal=2 public=2 */
    return 0;
}

internal=1 public=1
internal=2 public=2

Key Points

•External linkage = visible across translation units (default for globals)
•Internal linkage = file-private (use static at file scope)
•No linkage = block-local variables
•static on a function/global restricts it to the current file
•extern declares a variable/function defined elsewhere

Gotchas

•Two files both defining int x; (without static) causes a linker error: multiple definitions
•static at file scope means internal linkage; static on a local means persistent lifetime -- same keyword, different meaning
•Forgetting extern on a declaration can cause an accidental definition
•Header files should contain declarations (extern), not definitions, to avoid multiple definition errors

External linkage (default for globals): name shared across files. Internal linkage (static at file scope): name private to current file. No linkage: local variables. Use extern to reference variables from other files.

•static at file scope = internal linkage (file-private)
•extern = declare variable defined in another file

/* file1.c */
int shared = 10;           /* external linkage */
static int private = 20;   /* internal linkage */

/* file2.c */
#include <stdio.h>
extern int shared;  /* same variable from file1.c */
int main(void) {
    printf("%d\n", shared); /* 10 */
    return 0;
}

static means different things at file scope (linkage) vs block scope (lifetime)

Question 15 / 15

What does the volatile keyword do and when should you use it?

volatile tells the compiler that a variable's value may change at any time, outside the normal flow of the program. The compiler must:

Not optimize away reads -- must re-read from memory every time.
Not optimize away writes -- must write to memory every time.
Not reorder reads/writes to volatile variables relative to each other.

When to use volatile:

Memory-mapped hardware registers: The hardware can change the value at any time.
Variables modified by signal handlers: A signal can interrupt normal execution and modify a variable.
Variables shared with interrupt service routines (ISRs): In embedded systems.
setjmp/longjmp: Local variables modified between setjmp and longjmp must be volatile.

When NOT to use volatile:

For thread synchronization: volatile does NOT provide atomicity or memory ordering guarantees. Use _Atomic (C11) or platform-specific primitives.

volatile does NOT mean:

Atomic operations
Memory barriers/fences
Thread-safe access

Pseudo Code

1. volatile int x;  -- compiler must always read/write from/to memory
2. Without volatile: compiler may cache value in register, skip reads
3. Use for: hardware registers, signal handlers, ISRs
4. Do NOT use for: thread synchronization (use atomics instead)
5. volatile prevents compiler optimization, not CPU reordering

Code

#include <stdio.h>
#include <signal.h>

/* Signal handler sets this flag */
volatile sig_atomic_t got_signal = 0;

void handler(int sig) {
    (void)sig;
    got_signal = 1; /* modified in signal context */
}

int main(void) {
    signal(SIGINT, handler);

    printf("Waiting for Ctrl+C...\n");

    /* Without volatile, compiler might optimize this to:
     * if (!got_signal) { while(1); }
     * because it sees no modification in the loop body */
    while (!got_signal) {
        /* busy wait */
    }

    printf("Signal received!\n");

    /* Example: hardware register (embedded) */
    /* volatile unsigned int *status = (volatile unsigned int *)0x40021000; */
    /* while (!(*status & 0x01)) { } // must re-read every iteration */

    return 0;
}

Waiting for Ctrl+C...
(user presses Ctrl+C)
Signal received!

Key Points

•volatile prevents the compiler from optimizing away reads and writes
•Essential for hardware registers, signal handlers, and ISRs
•The compiler must re-read the variable from memory on every access
•sig_atomic_t with volatile is the correct type for signal flags
•volatile does NOT provide atomicity or memory ordering

Gotchas

•volatile does NOT make operations atomic -- volatile int x; x++ is still not thread-safe
•volatile does NOT prevent CPU instruction reordering -- only compiler reordering
•Using volatile for thread synchronization is a common mistake -- use _Atomic or mutexes
•Without volatile on a hardware register, the compiler may read it once and cache the result forever

volatile forces the compiler to re-read/re-write the variable from/to memory every time. Use it for hardware registers, signal handlers, and ISRs. It does NOT provide atomicity or thread safety.

•Forces re-read from memory every access
•NOT for thread safety -- use atomics

#include <stdio.h>
#include <signal.h>
volatile sig_atomic_t flag = 0;
void handler(int sig) { (void)sig; flag = 1; }
int main(void) {
    signal(SIGINT, handler);
    while (!flag) { /* must re-read flag each iteration */ }
    printf("Done\n");
    return 0;
}

(user presses Ctrl+C)
Done

volatile int x; x++ is NOT atomic -- still a read-modify-write

Built by onllm.dev

Home GitHub Support awesomePrep