C — Engineering
Notes for the Machine

$ cc -E a.c       # 1. preprocess only
$ cc -S a.c       # 2. → assembly
$ cc -c a.c       # 3. → a.o object file
$ cc a.o b.o -o app  # 4. link → executable

#include <stdint.h>
int32_t  a;   // exactly 32 bits, every platform
uint64_t b;   // exactly 64, unsigned
size_t   n;   // the type of sizeof / object sizes
ptrdiff_t d;  // the type of pointer differences

static int counter;        // file scope: internal linkage

int next(void) {
  static int n = 0;     // block scope: persists across calls
  return ++n;
}

unsigned u = 1;
if (-1 < u) puts("yes");   // NOT printed!
// -1 converts to a huge unsigned before the compare

int load(void) {
  FILE *f = fopen("x", "r");
  if (!f) goto err0;
  char *buf = malloc(1024);
  if (!buf) goto err1;
  // ... work ...
  free(buf);
  err1: fclose(f);
  err0: return -1;
}

int add(int, int);        // prototype in a header
int ticks(void);            // takes NO arguments
// int ticks();  ← old style: 'unspecified args', unsafe

int a[10];
sizeof a;            // 40 — here, a is an array

void f(int a[]) {
  sizeof a;          // 8 — a is a pointer here!
}

char s[6] = "hello";  // 5 chars + '\0' = 6
strlen(s);            // 5 (does not count '\0')
sizeof s;             // 6 (does count it)

struct S { char c; int i; char d; };
sizeof(struct S);   // 12, not 6 — alignment padding

struct S x = { .i = 5, .c = 'a' };  // designated init

union U { int i; float f; } u;
u.i = 1;
u.f;   // reading the other member: type-punning

typedef enum { RED, GREEN, BLUE } Color;
typedef struct { int x, y; } Point;
Point p = { .x = 1, .y = 2 };

int x = 42;
int *p = &x;     // p holds x's address
*p = 7;          // write through p → x is now 7
int *q = NULL;   // points nowhere; deref = crash/UB

int a[4] = {10,20,30,40};
int *p = a;
*(p + 2);    // 30 — advanced by 2*sizeof(int)
p[2];        // identical — a[i] is *(a+i)

int a[3], *p;
p = a;        // ok: array decays to &a[0]
// a = p;     ← error: 'a' is not assignable
// extern int a[];  declares an array
// extern int *a;   declares a pointer — NOT interchangeable

int *v = malloc(n * sizeof *v);  // sizeof *v: type-safe
if (!v) return -1;                // malloc can fail
// ... use v ...
free(v);
v = NULL;   // prevents use-after-free / double-free

int (*op)(int, int);     // pointer to int(int,int)
op = add;
op(2, 3);              // call through it

int (*table[])(int,int) = { add, sub, mul };
table[i](2, 3);        // O(1) dispatch by index

void print(const char *s);   // 'I won't modify s'
char *const p = buf;        // p can't be reseated

void copy(int *restrict d, const int *restrict s, int n);
// restrict: 'd and s never alias' → lets the compiler vectorise

#define SQR(x) ((x) * (x))   // every x parenthesised
SQR(a + 1);   // ((a+1)*(a+1)) — correct
// #define SQR(x) x*x  →  a+1*a+1  ← wrong

#define MAX(a,b) ((a) > (b) ? (a) : (b))
MAX(i++, j);   // i++ evaluated twice — side-effect bug

// math.h
#ifndef MATH_H
#define MATH_H
int add(int, int);   // declaration only
#endif

// math.c
#include "math.h"
int add(int a, int b) { return a + b; }  // definition

FILE *f = fopen("data.bin", "rb");
if (!f) { perror("fopen"); return -1; }
size_t got = fread(buf, 1, n, f);
if (got < n && ferror(f)) { /* I/O error */ }
fclose(f);

strncpy(d, s, n);   // may NOT NUL-terminate if s is long
d[n-1] = '\0';     // you must do this yourself

snprintf(d, n, "%s", s);  // always NUL-terminates: prefer this

#include <stdarg.h>
int sum(int count, ...) {
  va_list ap; va_start(ap, count);
  int s = 0;
  for (int i = 0; i < count; i++) s += va_arg(ap, int);
  va_end(ap);
  return s;
}

$ cc -fsanitize=address,undefined -g a.c   # ASan + UBSan
$ valgrind --leak-check=full ./app          # leaks + bad access
$ clang-tidy a.c; cppcheck a.c            # static analysis

int *p;              // p is a pointer to int
int *p[3];           // array of 3 pointers to int
int (*p)[3];         // pointer to array of 3 int
int (*f)(void);        // pointer to function returning int
int *f(void);          // function returning pointer to int
const int *p;        // pointer to const int (data is const)
int *const p;        // const pointer to int (pointer is const)