Engineering Computing (C)

C is compiled. A set of tools turns your text file into machine code the processor can run directly, which is why C is fast and why it dominates embedded work.

• Preprocessor: pastes in #include files and expands #define macros.
• Compiler: checks your code and translates it to assembly.
• Assembler: turns assembly into an object file of machine code.
• Linker: joins your object files and libraries into one executable.

#include <stdio.h>

int main(void) {
    printf("Hello, engineer!\n");
    return 0;
}

gcc -Wall -Wextra hello.c -o hello
./hello

Every variable lives at an address in memory. A pointer is a variable that stores one of those addresses. This lets a function change a caller's data, and it lets C talk directly to hardware.

• &: the address of a variable.
• *: follow a pointer to the value it points at.
• Pass by pointer: C copies arguments, so pass an address to change the original.
• NULL: a pointer to nothing. Following it crashes the program.

int a = 5;
int *p = &a;   // p holds a's address
*p = 9;        // a is now 9

void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

C trusts you completely. It does not check array bounds or free memory for you, so a small mistake can corrupt your data silently. Knowing the common bugs is half of writing safe C.

• Stack: automatic local variables, gone when the function returns.
• Heap: memory you ask for with malloc and must release with free.
• Buffer overflow: writing past the end of an array and corrupting whatever is next.
• Memory leak: forgetting to free, so usage grows until the program dies.
• Use after free: using memory after you gave it back.

char name[4];
strcpy(name, "Alexander");   // overflow!

snprintf(name, sizeof name, "%s", "Alexander");   // safe: cut to "Ale"