GATE rule: Unless specified, assume 32-bit system: int=4B, pointer=4B.
sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)
sizeof(float) ≤ sizeof(double) ≤ sizeof(long double)

C vs C++ trap:
C:    sizeof('a') = sizeof(int) = 4    (char literal is int in C)
C++: sizeof('a') = sizeof(char) = 1

static local — GATE favourite:

int counter() {
    static int c = 0;   // initialised once, persists across calls
    return ++c;
}
// counter() returns 1, 2, 3, ... on successive calls

static global: visible only within the file — prevents name clashes in multi-file programs.
extern: declares a variable defined in another translation unit — no storage allocation.

Precedence (high to low, key groups):
1. () [] → . (postfix)   2. ++ — (prefix) * & sizeof (unary)   3. * / %
4. + –   5. << >>   6. < <= > >=   7. == !=
8. & (bitwise)   9. ^   10. |   11. &&   12. ||   13. ?:
14. = += -= etc. (right-to-left)   15. , (comma)

Short-circuit evaluation (critical for GATE):
f() && g() — if f() returns 0, g() is never called.
f() || g() — if f() returns non-zero, g() is never called.
This affects programs with side effects (printf inside conditions).

for loop: for(init; cond; update) — update runs AFTER body.
while vs do-while: do-while executes body at least once (condition checked at bottom).

switch-case fallthrough:

switch(x) {
  case 1: printf("one");      // no break — falls through
  case 2: printf("two"); break;
  case 3: printf("three");
}
// if x=1: prints "onetwo". Fallthrough is intentional C behaviour.

break vs continue vs goto:
break: exits innermost loop/switch.   continue: skips to next iteration.   goto: unconditional jump (avoid).

Dangling else: else binds to the nearest unmatched if.

if (a) if (b) x=1; else x=2;  // else belongs to inner if(b)

Preprocessor runs before compilation. It does text substitution — no type checking.

#define macro traps:

#define SQ(x) x*x
SQ(3+2) → 3+2*3+2 = 11  (not 25!)
// Fix: #define SQ(x) ((x)*(x))

#ifdef / #ifndef: Conditional compilation for platform-specific code.
#include “file” searches current directory first; #include <file> searches system paths.

sizeof vs macro:
sizeof is a compile-time operator, not a function — sizeof(int) not sizeof int().
#define MAX(a,b) ((a)>(b)?(a):(b)) evaluates arguments twice — use inline functions instead.

Integer promotion: char and short are promoted to int in expressions.
Usual arithmetic conversion (lower → higher):
char → int → unsigned int → long → unsigned long → float → double → long double

Common GATE traps:

char c = 255;
printf("%d", c);        // -1 (signed char overflow → implementation-defined)

unsigned int a = 5, b = 10;
printf("%d", a - b);    // large positive number! (wraps around in unsigned)

int x = 3, y = 2;
float f = x/y;          // f = 1.0, not 1.5 (integer division first)
float g = (float)x/y;  // g = 1.5 (correct)

GATE 2018 — What is the output?

#include <stdio.h>
int f(int n) {
    static int r = 0;
    if (n <= 0) return 1;
    if (n > 3) { r = n; return f(n-2) + 2; }
    return f(n-1) + r;
}
int main() { printf("%d", f(5)); }

Trace: f(5): r=5, f(3)+2.   f(3): f(2)+r=f(2)+5.   f(2): f(1)+r=f(1)+5.   f(1): f(0)+r=1+5=6.
f(2)=6+5=11. f(3)=11+5=16. f(5)=16+2=18.   Output: 18

GATE 2020 — What does this print?

#include <stdio.h>
#define MAX(x,y) (x>y?x:y)
int main() {
    int a=2, b=3;
    printf("%d", MAX(a++, b++));
}

Macro expands to: (a++>b++?a++:b++). a++=2, b++=3, 2>3 is false, so b++ = 4 (post-increment after b was already incremented in condition). Output: 4

GATE 2022 — Storage class question:

void f() {
    static int x = 5;
    x++;
    printf("%d ", x);
}
int main() { f(); f(); f(); }

First call: x initialised to 5, incremented to 6. Second: x persists as 6, becomes 7. Third: 8.
Output: 6 7 8