C fundamentals

# Debug build: warnings, symbols and runtime checks
gcc -std=c23 -Wall -Wextra -pedantic -g -O0 \
    -fsanitize=address,undefined main.c -o main
./main
echo "exit status: $?"
 
# Release build
clang -std=c23 -Wall -Wextra -O2 -DNDEBUG main.c -o main
 
# Stop after one stage to look at its output
gcc -E main.c -o main.i      # preprocessed C
gcc -S main.c                # main.s: assembly
gcc -c main.c                # main.o: object file
gcc main.o util.o -o app     # link two objects
nm main.o                    # symbols: T defined, U needed

#include <stdio.h>
 
int main(void) {
    int count = 3
    printf("%s items\n", count);
    return total;
}

$ gcc -Wall -Wextra oops.c
oops.c: In function 'main':
oops.c:5:5: error: expected ',' or ';' before 'printf'
    5 |     printf("%s items\n", count);
      |     ^~~~~~
oops.c:6:12: error: 'total' undeclared (first use in this function)
    6 |     return total;
      |            ^~~~~
oops.c:4:9: warning: unused variable 'count' [-Wunused-variable]

#include <stdio.h>   // printf, fprintf
#include <stdlib.h>  // EXIT_SUCCESS, EXIT_FAILURE
 
int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s NAME...\n", argv[0]);
        return EXIT_FAILURE;  // nonzero means failure
    }
    for (int i = 1; i < argc; i++)
        printf("hello, %s\n", argv[i]);
    return EXIT_SUCCESS;      // 0
}

cc -std=c23 -Wall -Wextra hello.c -o hello
./hello Ada Linus    # hello, Ada / hello, Linus
./hello; echo $?     # usage message, then 1

#include <inttypes.h>   // PRId64 etc.; includes <stdint.h>
#include <limits.h>
#include <stdio.h>
 
int main(void) {
    printf("int is %zu bytes: %d..%d\n", sizeof(int),
           INT_MIN, INT_MAX);
    int64_t big = INT64_MAX;
    uint8_t byte = 255;
    printf("%" PRId64 " %" PRIu8 "\n", big, byte);
}

#include <limits.h>
#include <stdckdint.h>   // C23 checked arithmetic
#include <stdio.h>
 
int main(void) {
    int a = 2'000'000'000, b = 2'000'000'000, sum;
    if (ckd_add(&sum, a, b))      // true if it overflowed
        puts("overflow");   // sum holds the wrapped value
 
    unsigned u = 0;
    u -= 1;                       // fine: wraps to UINT_MAX
    printf("%u %d\n", u, u == UINT_MAX);
 
    double avg = (double)a / 3;   // cast first, then divide
    printf("%.2f\n", avg);
}

#include <stdint.h>
#include <stdio.h>
 
#define MAX_USERS 100        // text substitution, no type
enum { BUF_SIZE = 256 };     // a true int constant, OK in
                             // array sizes and case labels
constexpr int kRetries = 3;  // C23: typed compile-time value
constexpr double kPi = 3.14159265358979;
const int limit = 10;        // a read-only variable, NOT a
                             // constant expression in C
 
char buf[BUF_SIZE];
int attempts[kRetries];
static_assert(sizeof buf == 256);   // C23: no message needed
 
enum color { RED, GREEN = 5, BLUE };       // 0, 5, 6
enum perm : uint8_t { P_READ = 1, P_WRITE = 2 }; // C23
 
int main(void) {
    enum perm p = P_READ | P_WRITE;
    printf("%d %.4f %zu %d\n", kRetries, kPi, sizeof p,
           BLUE);
}   // 3 3.1416 1 6

#include <stdio.h>
 
int main(void) {
    const char *text = "a quick test, ok?";
    int vowels = 0, spaces = 0, other = 0;
 
    for (const char *c = text; *c != '\0'; c++) {
        switch (*c) {            // integers and chars only
        case 'a': case 'e': case 'i': case 'o': case 'u':
            vowels++;
            break;               // without it: falls through
        case ' ':
            spaces++;
            [[fallthrough]];     // C23: intentional
        default:
            other++;
        }
    }
    printf("%d vowels, %d spaces, %d other\n",
           vowels, spaces, other);
 
    int n = 10;
    while (n > 1) n = (n % 2) ? 3 * n + 1 : n / 2;
    do { n--; } while (n > 0);   // body runs at least once
}

#include <stdio.h>
 
// Copy a file; returns 0 on success, -1 on any error.
int copy_file(const char *from, const char *to) {
    int rc = -1;
    FILE *in = nullptr, *out = nullptr;
    char buf[4096];
    size_t n;
 
    if (!(in = fopen(from, "rb"))) goto done;
    if (!(out = fopen(to, "wb"))) goto done;
    while ((n = fread(buf, 1, sizeof buf, in)) > 0)
        if (fwrite(buf, 1, n, out) != n) goto done;
    if (ferror(in)) goto done;
    rc = 0;
done:
    if (out && fclose(out) != 0) rc = -1;
    if (in) fclose(in);
    return rc;
}

#include <stdio.h>
 
// Prototype: lets main call it before the definition
static double average(const int *xs, size_t n);
 
static void swap(int *a, int *b) {  // pointers: modify
    int t = *a;                      // the caller's values
    *a = *b;
    *b = t;
}
 
static int next_id(void) {
    static int id = 0;     // static local: keeps its value
    return ++id;           // between calls
}
 
int main(void) {
    int scores[] = {90, 72, 85};
    printf("%.1f\n", average(scores, 3));   // 82.3
    int x = 1, y = 2;
    swap(&x, &y);
    printf("%d %d %d\n", x, y, next_id());  // 2 1 1
}
 
static double average(const int *xs, size_t n) {
    if (n == 0) return 0.0;
    long long sum = 0;
    for (size_t i = 0; i < n; i++) sum += xs[i];
    return (double)sum / (double)n;
}

#include <stdarg.h>
#include <stdio.h>
 
[[gnu::format(printf, 2, 3)]]   // GCC/Clang: check formats
void log_msg(const char *level, const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);     // C23 also allows va_start(ap)
    fprintf(stderr, "[%s] ", level);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fputc('\n', stderr);
}
 
#define type_name(x) _Generic((x), \
    int: "int", double: "double", char *: "char *", \
    default: "other")
 
int main(void) {
    log_msg("info", "%d users, %s", 3, type_name(2.5));
}

#ifndef STACK_H          // include guard: the second
#define STACK_H          // #include of this file is empty
 
#include <stddef.h>      // size_t
 
#define STACK_CAP 64
 
typedef struct {
    int items[STACK_CAP];
    size_t len;
} Stack;
 
void stack_init(Stack *s);
bool stack_push(Stack *s, int value);  // false when full
bool stack_pop(Stack *s, int *out);    // false when empty
 
extern long stack_pushes;  // declared here, defined in
                           // stack.c
#endif

#include "stack.h"
 
long stack_pushes = 0;     // the one definition
 
static bool is_full(const Stack *s) {  // private helper
    return s->len == STACK_CAP;
}
 
void stack_init(Stack *s) { s->len = 0; }
 
bool stack_push(Stack *s, int value) {
    if (is_full(s)) return false;
    s->items[s->len++] = value;
    stack_pushes++;
    return true;
}
 
bool stack_pop(Stack *s, int *out) {
    if (s->len == 0) return false;
    *out = s->items[--s->len];
    return true;
}

#include <stdio.h>
#include "stack.h"
 
int main(void) {
    Stack s;
    stack_init(&s);
    for (int i = 1; i <= 3; i++) stack_push(&s, i * 10);
    int top;
    while (stack_pop(&s, &top)) printf("%d ", top);
    printf("\n%ld pushes\n", stack_pushes);
}   // prints "30 20 10", then "3 pushes"

cc -std=c23 -Wall -Wextra -Iinclude src/main.c src/stack.c \
   -o stack-demo

#include <stdio.h>
 
#define SQUARE(x) ((x) * (x))     // parenthesize everything
#define ARRAY_LEN(a) (sizeof (a) / sizeof (a)[0])
#define SWAP(a, b) do {           \
        typeof(a) tmp_ = (a);     \
        (a) = (b);                \
        (b) = tmp_;               \
    } while (0)                   // acts like one statement
#define STR(x) #x                 // stringize: "x"
#define CAT(a, b) a##b            // paste: ab
 
#ifdef DEBUG                      // cc -DDEBUG ...
#  define LOG(...) fprintf(stderr, __VA_ARGS__)
#else
#  define LOG(...) ((void)0)
#endif
 
int main(void) {
    int xs[] = {3, 1, 2};
    int a = 1, b = 2;
    SWAP(a, b);
    int CAT(total, _count) = SQUARE(a + 1);  // 9
    LOG("%s:%d\n", __FILE__, __LINE__);
    printf("%zu %s %d\n", ARRAY_LEN(xs), STR(a + b),
           total_count);
}

#if defined(_WIN32)
#  include <windows.h>
#elif defined(__linux__) || defined(__APPLE__)
#  include <unistd.h>
#endif
 
#if __STDC_VERSION__ >= 202311L    // compiling as C23?
#  define HAS_C23 1
#endif
 
#if __has_include(<threads.h>)     // C23 (earlier as an
#  include <threads.h>             // extension)
#endif

static const unsigned char icon_png[] = {
#embed "icon.png"
};
// sizeof icon_png is the file size, known at compile time

#include <stdio.h>
#include <string.h>
 
int main(void) {
    int primes[5] = {2, 3, 5, 7, 11};
    int zeros[100] = {0};      // missing elements are 0
    int counts[26] = {};       // C23 empty initializer
    double grid[3][4] = {};    // 3 rows of 4, contiguous
    int sparse[10] = {[2] = 1, [9] = 4};  // designated
 
    size_t n = sizeof primes / sizeof primes[0];   // 5
    for (size_t i = 0; i < n; i++) printf("%d ", primes[i]);
 
    int copy[5];
    memcpy(copy, primes, sizeof primes); // not copy = primes
    printf("\n%d %d %g %d %d\n", zeros[99], counts[0],
           grid[2][3], sparse[9], copy[4]);
}

#include <stdio.h>
#include <string.h>
 
int main(void) {
    char name[16];
    int n = snprintf(name, sizeof name, "%s-%d", "user", 42);
    if (n < 0 || (size_t)n >= sizeof name)
        puts("truncated");
    printf("%s has %zu chars\n", name, strlen(name));
 
    if (strcmp(name, "user-42") == 0) puts("equal");
    const char *dash = strchr(name, '-');
    if (dash) printf("suffix: %s\n", dash + 1);
}

#include <stdio.h>
 
struct point { double x, y; };
 
typedef struct {               // anonymous struct + alias
    char name[32];
    int age;
    struct point home;
} Person;
 
static void move_home(Person *p, struct point to) {
    p->home = to;              // p->m is (*p).m
}
 
int main(void) {
    struct point origin = {0};             // all zero
    struct point q = {.y = 5.0};           // x is 0.0
    Person ada = {
        .name = "Ada",
        .age = 36,
        .home = {.x = 51.5, .y = -0.12},
    };
    Person copy = ada;          // copies every byte, the
    copy.age++;                 // name array included
    move_home(&ada, (struct point){.x = 3, .y = 4});
    printf("%s %d %d %.1f %.1f %.1f\n", ada.name, ada.age,
           copy.age, ada.home.x, q.y, origin.x);
}

#include <stdio.h>
 
typedef enum { SHAPE_CIRCLE, SHAPE_RECT } ShapeKind;
 
typedef struct {
    ShapeKind kind;            // says which member is live
    union {                    // anonymous union (C11)
        struct { double r; } circle;
        struct { double w, h; } rect;
    };
} Shape;
 
static double area(Shape s) {
    switch (s.kind) {
    case SHAPE_CIRCLE:
        return 3.14159265 * s.circle.r * s.circle.r;
    case SHAPE_RECT:
        return s.rect.w * s.rect.h;
    }
    return 0.0;
}
 
int main(void) {
    Shape shapes[] = {
        {.kind = SHAPE_CIRCLE, .circle = {.r = 1.0}},
        {.kind = SHAPE_RECT, .rect = {.w = 2, .h = 3}},
    };
    for (size_t i = 0; i < 2; i++)
        printf("%.2f\n", area(shapes[i]));
}

#include <stdio.h>
#include <string.h>
 
int main(void) {
    FILE *f = fopen("scores.txt", "w");
    if (f == nullptr) {
        perror("scores.txt");        // why it failed
        return 1;
    }
    fprintf(f, "ada 36\nlin 41\n");
    if (fclose(f) != 0) {            // flushes: can fail
        perror("fclose");
        return 1;
    }
 
    f = fopen("scores.txt", "r");
    if (!f) { perror("scores.txt"); return 1; }
    char name[32];
    int score;
    while (fscanf(f, "%31s %d", name, &score) == 2)
        printf("%-6s%4d\n", name, score);
    fclose(f);
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef enum { ERR_OK, ERR_OPEN, ERR_READ } Err;
 
static const char *err_str(Err e) {
    switch (e) {
    case ERR_OK: return "ok";
    case ERR_OPEN: return "cannot open";
    case ERR_READ: return "read failed";
    }
    return "unknown";
}
 
[[nodiscard]] static Err first_line(const char *path,
                                    char *buf, int size) {
    FILE *f = fopen(path, "r");
    if (!f) {
        fprintf(stderr, "%s: %s\n", path, strerror(errno));
        return ERR_OPEN;
    }
    Err e = fgets(buf, size, f) ? ERR_OK : ERR_READ;
    fclose(f);
    return e;
}
 
int main(int argc, char *argv[]) {
    char line[256];
    Err e = first_line(argc > 1 ? argv[1] : "/etc/hostname",
                       line, sizeof line);
    if (e != ERR_OK) {
        fprintf(stderr, "error: %s\n", err_str(e));
        return EXIT_FAILURE;
    }
    fputs(line, stdout);
}

#include <limits.h>
 
// Looks like an overflow check, but x + 1 overflowing is
// UB, so the compiler may assume it cannot happen and
// compile this to `return false` (GCC and Clang at -O2 do)
bool next_overflows_bad(int x) { return x + 1 < x; }
 
// Correct: compare before doing the arithmetic
bool next_overflows(int x) { return x == INT_MAX; }
 
bool add_overflows(int a, int b) {
    return (b > 0 && a > INT_MAX - b) ||
           (b < 0 && a < INT_MIN - b);
}

CFLAGS = -std=c23 -Wall -Wextra -pedantic -g
 
app: main.o util.o            # target: prerequisites
	$(CC) $(CFLAGS) main.o util.o -o app
 
main.o: main.c util.h
	$(CC) $(CFLAGS) -c main.c
 
util.o: util.c util.h
	$(CC) $(CFLAGS) -c util.c