Functions

/* ── FUNCTION DECLARATION (prototype) ── */

int  add(int a, int b);
 ^    ^   ^           ^
 |    |   |           └── semicolon: ends a declaration (no body)
 |    |   └────────────── parameter list: type + name pairs (names optional in decl)
 |    └────────────────── function name (identifier)
 └─────────────────────── return type: what the function hands back to its caller

/* ── FUNCTION DEFINITION ── */

int  add(int a, int b)  {
    int result = a + b;   /* local variable — lives only during this call */
    return result;           /* return statement: sends value back to caller  */
}
 ^                      ^
 |                      └── closing brace ends the function body
 └─────────────────────── opening brace starts the function body

/* ── VOID FUNCTION (no return value) ── */

void  print_double(int x)  {
    printf("%d\n", x * 2);
    /* no return statement needed (or use bare "return;") */
}

/* ── VOID PARAMETERS (no parameters at all) ── */

int  get_magic_number(void)  {
    return 42;
    /* "void" in parameter list means "this function takes NO arguments" */
}

/* foo.h — the header file declares the interface */
extern int foo(int x);
 ^
 └── "extern" = defined in another .c file, linker will find it

/* foo.c — the .c file defines the implementation */
int foo(int x) { return x * 2; }

/* main.c — includes the header to know about foo */
#include "foo.h"
int main(void) { foo(5); return 0; }

int global_count = 0;  /* global scope — visible in ALL functions in this file */

void increment(void) {
    int step = 1;        /* local scope — exists ONLY while increment() runs */
    global_count += step;
}                      /* 'step' is destroyed here — memory returned to stack */

void show(void) {
    /* step is invisible here — "undeclared identifier" if you try to use it */
    printf("%d\n", global_count);  /* global_count IS visible */
}

static int secret = 7;  /* file scope only — invisible to other .c files */

/* A function pointer stores the address of a function */
/* Type: "pointer to function taking (int,int) and returning int" */

int (*fp)(int, int);
 ^    ^  ^
 |    |  └── parameter types of the function being pointed to
 |    └───── * inside parens = this is a function POINTER, not a function call
 └────────── return type of the pointed-to function

fp = add;          /* assign — function name without () is its address */
int r = fp(3, 4);  /* call via pointer — r == 7 */

#include <stdarg.h>   /* provides: va_list, va_start, va_arg, va_end */

/* Variadic function: accepts variable number of arguments         */
/* The '...' means "zero or more additional arguments of any type" */
/* You MUST have at least one fixed parameter before '...'         */

int my_sum(int count, ...) {         /* count = how many ints follow */
    va_list args;
    va_start(args, count);           /* initialize; 'count' = last fixed param */

    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(args, int);  /* read next arg as specified type */
    }

    va_end(args);    /* REQUIRED — clean up va_list before returning */
    return total;
}
/* my_sum(3, 10, 20, 30)   → 60  */
/* my_sum(5, 1, 2, 3, 4, 5) → 15 */

/* This is exactly how printf() works:                      */
/* int printf(const char *format, ...)                      */
/* When printf sees "%d" it calls va_arg(args, int)         */
/* When it sees "%s" it calls va_arg(args, char *)          */

#include <stdlib.h>   /* rand(), srand(), RAND_MAX */
#include <time.h>     /* time() — needed for time-based seed */

/* rand() — returns a pseudo-random int in [0, RAND_MAX] */
/* RAND_MAX is at least 32767; typically 2147483647 on 64-bit systems */
int r = rand();                              /* 0 to RAND_MAX */
int die = (rand() % 6) + 1;               /* 1 to 6 */
double frac = (double)rand() / RAND_MAX;  /* 0.0 to 1.0 */

/* srand(seed) — seeds the generator; same seed → same sequence */
srand(42);           /* fixed seed: reproducible (useful for testing) */
srand(time(NULL));    /* time-based seed: different each run */

/* Helper: random int in closed range [lo, hi] */
int random_in_range(int lo, int hi) {
    return lo + rand() % (hi - lo + 1);
}

int main(int argc, char **argv)
           ^           ^
           |           └── array of strings (char*); each argv[i] is one argument
           └───────────── count of arguments INCLUDING the program name itself

/* Running: ./hello world 42 */
/* argc == 3 */
/* argv[0] == "./hello"   (always the program name) */
/* argv[1] == "world"     (first user argument) */
/* argv[2] == "42"        (second user argument — still a STRING, not int!) */
/* argv[3] == NULL        (sentinel — array is NULL-terminated) */

#include <stdio.h>
#include <stdlib.h>   /* for atoi() */

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <name> <number>\n", argv[0]);
        return 1;       /* non-zero exit = error */
    }
    int n = atoi(argv[2]);   /* convert string "42" to integer 42 */
    printf("Hello, %s! Number is %d\n", argv[1], n);
    return 0;
}