C / C++ on Software Engineering Learning Paths

C Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

C Fundamentals#

C is a small language — about 30 keywords, no classes, no exceptions, no garbage collector. It compiles to machine code, gives you direct hardware access, and trusts you to manage everything yourself. This is both its power and its danger.

Hello World#

#include <stdio.h>

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

gcc -o hello hello.c
./hello

Anatomy#

Part	Purpose
`#include <stdio.h>`	Preprocessor directive — includes standard I/O declarations
`int main(void)`	Entry point, returns int (0 = success, nonzero = error)
`printf()`	Formatted output to stdout
`return 0`	Exit code to the OS

Compilation Pipeline#

source.c → [Preprocessor] → source.i → [Compiler] → source.s → [Assembler] → source.o → [Linker] → executable

Stage	Tool	What It Does
Preprocessing	`cpp`	Expands `#include`, `#define`, conditional compilation
Compilation	`cc1`	Translates C to assembly
Assembly	`as`	Translates assembly to machine code (object file)
Linking	`ld`	Combines object files + libraries into executable

gcc -E hello.c > hello.i # preprocess only
gcc -S hello.c # compile to assembly
gcc -c hello.c # compile to object file
gcc -o hello hello.c # full pipeline

Compiler Flags You Should Always Use#

gcc -Wall -Wextra -Werror -std=c17 -pedantic -O2 -o myapp main.c

Flag	Purpose
`-Wall`	Enable most warnings
`-Wextra`	Additional warnings
`-Werror`	Treat warnings as errors
`-std=c17`	Use C17 standard
`-pedantic`	Strict standard compliance
`-O2`	Optimisation level 2
`-g`	Include debug symbols
`-fsanitize=address`	AddressSanitizer (catches memory bugs)

Types#

Integer Types#

Type	Minimum Size	Typical Size	Range (typical)
`char`	1 byte	1 byte	-128 to 127 or 0 to 255
`short`	2 bytes	2 bytes	-32,768 to 32,767
`int`	2 bytes	4 bytes	-2³¹ to 2³¹-1
`long`	4 bytes	4 or 8 bytes	Platform-dependent
`long long`	8 bytes	8 bytes	-2⁶³ to 2⁶³-1

Use fixed-width types from <stdint.h> for portability:

Pointers & Memory

Mon, 01 Jan 0001 00:00:00 +0000

Pointers & Memory#

Pointers are the most powerful and most dangerous feature of C. A pointer is a variable that holds a memory address. Understanding pointers is understanding how the computer actually manages data.

What Is a Pointer?#

int x = 42;
int *p = &x; // p holds the address of x

printf("%d\n", x); // 42 (the value)
printf("%p\n", (void*)p); // 0x7ffd5e8c3a4c (the address)
printf("%d\n", *p); // 42 (dereference — read value at address)

*p = 100; // write through the pointer
printf("%d\n", x); // 100 (x was modified via p)

Operation	Syntax	Meaning
Declare pointer	`int *p`	p is a pointer to int
Address-of	`&x`	Get the address of x
Dereference	`*p`	Access the value at address p
NULL pointer	`NULL` or `(void*)0`	Points to nothing

Stack vs Heap#

┌─────────────────────┐ High address
│ Stack │ ← function locals, grows downward
│ (automatic, LIFO) │
├─────────────────────┤
│ ↓ │
│ (free space) │
│ ↑ │
├─────────────────────┤
│ Heap │ ← malloc'd memory, grows upward
│ (dynamic, manual) │
├─────────────────────┤
│ Data (BSS + init) │ ← globals, statics
├─────────────────────┤
│ Text │ ← program code (read-only)
└─────────────────────┘ Low address

Memory Region	Allocated By	Freed By	Lifetime
Stack	Function call	Function return	Automatic
Heap	`malloc()`, `calloc()`	`free()`	Manual
Data (global)	Program start	Program end	Program lifetime
Text (code)	Program load	Program end	Program lifetime

Dynamic Memory#

#include <stdlib.h>

// Allocate
int *arr = malloc(10 * sizeof(int)); // 10 ints, UNINITIALIZED
int *arr = calloc(10, sizeof(int)); // 10 ints, ZEROED

// Check for failure
if (arr == NULL) {
 perror("malloc failed");
 exit(1);
}

// Use
arr[0] = 42;
arr[9] = 100;

// Resize
arr = realloc(arr, 20 * sizeof(int)); // grow to 20 ints

// Free
free(arr);
arr = NULL; // prevent use-after-free

The Four Memory Bugs#

Bug	Cause	Consequence
Memory leak	`malloc` without `free`	Unbounded memory growth
Use-after-free	Dereference after `free`	Undefined behaviour (crash, corruption)
Double free	`free` the same pointer twice	Heap corruption
Buffer overflow	Write past allocated bounds	Stack smashing, code execution

// LEAK — forgot to free
void leak(void) {
 int *p = malloc(100);
 return; // p is lost, 100 bytes leaked
}

// USE-AFTER-FREE
int *p = malloc(sizeof(int));
*p = 42;
free(p);
printf("%d\n", *p); // UNDEFINED BEHAVIOUR

// DOUBLE FREE
free(p);
free(p); // UNDEFINED BEHAVIOUR

// BUFFER OVERFLOW
int arr[5];
arr[10] = 42; // writes beyond array bounds — UNDEFINED BEHAVIOUR

Pointer Arithmetic#

Pointers can be incremented and decremented. The step size is the size of the pointed-to type:

Strings & Arrays

Mon, 01 Jan 0001 00:00:00 +0000

Strings & Arrays#

C has no string type. A “string” is a char array terminated by a null byte ('\0'). This simplicity is elegant but requires constant vigilance against buffer overflows.

C Strings#

char greeting[] = "Hello"; // compiler adds '\0', size = 6
char *ptr = "World"; // points to string literal (read-only!)

// Memory layout of greeting:
// ['H','e','l','l','o','\0']
// [0] [1] [2] [3] [4] [5]

String Length vs Array Size#

char s[] = "Hello";
strlen(s); // 5 (characters, NOT including '\0')
sizeof(s); // 6 (bytes, INCLUDING '\0')

String Functions (`<string.h>`)#

Function	Purpose	Danger
`strlen(s)`	Length (without ‘\0’)	Scans until ‘\0’ — O(n)
`strcpy(dst, src)`	Copy string	No bounds checking — use `strncpy`
`strncpy(dst, src, n)`	Copy at most n chars	May not null-terminate!
`strcat(dst, src)`	Concatenate	No bounds checking — use `strncat`
`strcmp(a, b)`	Compare (0 = equal)	Returns int, not bool
`strncmp(a, b, n)`	Compare first n chars
`strchr(s, c)`	Find first occurrence of c	Returns NULL if not found
`strstr(s, sub)`	Find substring	Returns NULL if not found
`strtok(s, delim)`	Tokenise (destructive!)	Modifies the original string
`snprintf(buf, n, fmt, ...)`	Safe formatted print to buffer	Preferred — always bounds-checked

Safe String Handling#

// BAD — buffer overflow
char buf[10];
strcpy(buf, "This string is way too long for the buffer");

// GOOD — bounded
char buf[10];
snprintf(buf, sizeof(buf), "Hello %s", name);
// Always null-terminates, truncates if necessary

Rule: Always use snprintf instead of sprintf, strncpy instead of strcpy. Better yet, track buffer sizes explicitly.

Structs & Unions

Mon, 01 Jan 0001 00:00:00 +0000

Structs & Unions#

Structs group related data into a single type. Unions overlay multiple fields in the same memory. Together with enums and bitfields, they let you model any data layout — from database records to hardware registers.

Structs#

struct Point {
 double x;
 double y;
};

struct Point origin = {0.0, 0.0}; // positional init
struct Point p = {.x = 3.0, .y = 4.0}; // designated init (C99)

printf("(%f, %f)\n", p.x, p.y);

// Pointer access
struct Point *pp = &p;
printf("(%f, %f)\n", pp->x, pp->y); // -> dereferences + accesses

Typedef#

typedef struct {
 int id;
 char name[64];
 double salary;
} Employee;

Employee e = {1, "Alice", 95000.0};

Structs with Pointers#

typedef struct Node {
 int value;
 struct Node *next; // self-referential — must use full struct name
} Node;

Node a = {1, NULL};
Node b = {2, &a};
// b -> a -> NULL

Memory Layout and Alignment#

The compiler inserts padding to align struct fields to their natural boundaries:

The Preprocessor & Compilation

Mon, 01 Jan 0001 00:00:00 +0000

The Preprocessor & Compilation#

The C preprocessor is a text substitution engine that runs before compilation. It handles file inclusion, macro expansion, and conditional compilation. Understanding it is essential because it explains header files, include guards, and half the cryptic compiler errors you will encounter.

#include#

#include <stdio.h> // search system include paths
#include "myheader.h" // search current directory first, then system paths

#include literally copies the file contents into your source. A header file is just a C file that gets pasted in.

File I/O & System Calls

Mon, 01 Jan 0001 00:00:00 +0000

File I/O & System Calls#

C provides two layers of file I/O: the standard library (<stdio.h>) for portable, buffered I/O, and POSIX system calls for low-level, unbuffered access. Understanding both is essential for systems programming.

Standard I/O (`<stdio.h>`)#

Opening and Closing Files#

FILE *fp = fopen("data.txt", "r");
if (!fp) {
 perror("fopen"); // prints: "fopen: No such file or directory"
 return 1;
}

// ... use fp ...

fclose(fp);

Mode	Meaning
`"r"`	Read (file must exist)
`"w"`	Write (truncates or creates)
`"a"`	Append (creates if needed)
`"r+"`	Read + write (file must exist)
`"w+"`	Read + write (truncates or creates)
`"rb"`	Read binary
`"wb"`	Write binary

Reading#

// Read character by character
int ch;
while ((ch = fgetc(fp)) != EOF) {
 putchar(ch);
}

// Read line by line
char line[256];
while (fgets(line, sizeof(line), fp)) {
 printf("%s", line); // line includes '\n'
}

// Read formatted
int id;
char name[64];
fscanf(fp, "%d %63s", &id, name);

// Read binary
size_t n = fread(buffer, sizeof(int), count, fp);

Writing#

fprintf(fp, "User %d: %s\n", id, name);
fputs("hello\n", fp);
fputc('A', fp);
fwrite(data, sizeof(int), count, fp);

Standard Streams#

Stream	File Descriptor	Purpose
`stdin`	0	Standard input
`stdout`	1	Standard output (line-buffered)
`stderr`	2	Standard error (unbuffered)

POSIX I/O (Low-Level)#

Direct system calls — no buffering, no formatting, works with file descriptors (integers):

C++ Core

Mon, 01 Jan 0001 00:00:00 +0000

C++ Core#

C++ extends C with classes, references, namespaces, and RAII (Resource Acquisition Is Initialization). This section covers the foundational C++ features that replace C’s manual patterns with safer, more expressive abstractions.

Classes#

class User {
public:
 // Constructor
 User(std::string name, int age)
 : name_(std::move(name)), age_(age) {}

 // Destructor (called automatically when object is destroyed)
 ~User() = default;

 // Getter
 const std::string& name() const { return name_; }
 int age() const { return age_; }

 // Method
 std::string greeting() const {
 return "Hello, " + name_ + "!";
 }

private:
 std::string name_;
 int age_;
};

User alice("Alice", 30);
std::cout << alice.greeting() << std::endl;

Constructor Initialiser Lists#

Always use initialiser lists — they initialise members directly instead of default-constructing then assigning:

C++ Object-Oriented

Mon, 01 Jan 0001 00:00:00 +0000

C++ Object-Oriented Programming#

C++ supports classical OOP — inheritance, polymorphism, encapsulation, and abstract classes. Modern C++ uses OOP selectively, favouring composition and generic programming for most designs.

Inheritance#

class Shape {
public:
 Shape(double x, double y) : x_(x), y_(y) {}
 virtual ~Shape() = default; // virtual destructor — essential for polymorphism

 double x() const { return x_; }
 double y() const { return y_; }

 virtual double area() const = 0; // pure virtual — must be overridden
 virtual std::string name() const = 0;

 virtual void describe() const {
 std::cout << name() << " at (" << x_ << ", " << y_
 << ") area=" << area() << std::endl;
 }

private:
 double x_, y_;
};

class Circle : public Shape {
public:
 Circle(double x, double y, double radius)
 : Shape(x, y), radius_(radius) {}

 double area() const override { return M_PI * radius_ * radius_; }
 std::string name() const override { return "Circle"; }

private:
 double radius_;
};

class Rectangle : public Shape {
public:
 Rectangle(double x, double y, double w, double h)
 : Shape(x, y), width_(w), height_(h) {}

 double area() const override { return width_ * height_; }
 std::string name() const override { return "Rectangle"; }

private:
 double width_, height_;
};

Key Rules#

Rule	Why
Always make base class destructor `virtual`	Prevents undefined behaviour when deleting through base pointer
Use `override` keyword	Catches signature mismatches at compile time
Use `= 0` for pure virtual (abstract)	Forces derived classes to implement
Prefer `public` inheritance	Models “is-a” relationship

Polymorphism#

void print_shapes(const std::vector<std::unique_ptr<Shape>>& shapes) {
 for (const auto& shape : shapes) {
 shape->describe(); // virtual dispatch — correct method called
 }
}

std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(0, 0, 5));
shapes.push_back(std::make_unique<Rectangle>(1, 1, 3, 4));
print_shapes(shapes);

Virtual Functions Internals#

Each class with virtual functions has a vtable — a table of function pointers. Each object carries a hidden vptr pointing to its class’s vtable. Virtual calls are indirect function calls through this table.

Templates & STL

Mon, 01 Jan 0001 00:00:00 +0000

Templates & STL#

Templates are C++’s generic programming mechanism — compile-time code generation that produces type-specific implementations with zero runtime overhead. The Standard Template Library (STL) is built entirely on templates and provides containers, algorithms, and iterators.

Function Templates#

template<typename T>
T max_of(T a, T b) {
 return (a > b) ? a : b;
}

max_of(3, 5); // int
max_of(3.14, 2.71); // double
max_of<std::string>("alice", "bob"); // explicit type

The compiler generates a separate function for each type used — this is monomorphisation. Zero overhead at runtime; binary size may increase.

Modern C++

Mon, 01 Jan 0001 00:00:00 +0000

Modern C++#

C++11 through C++23 transformed the language. Smart pointers, move semantics, lambdas, auto, and std::optional make modern C++ drastically safer and more expressive than pre-2011 code.

Smart Pointers#

Replace raw new/delete with RAII-managed pointers:

`std::unique_ptr` — Exclusive Ownership#

#include <memory>

auto user = std::make_unique<User>("Alice", 30); // allocates on heap
user->greet(); // use like a raw pointer

// Automatically deleted when unique_ptr goes out of scope
// Cannot be copied — only moved
auto user2 = std::move(user); // user is now nullptr

`std::shared_ptr` — Shared Ownership#

auto data = std::make_shared<std::vector<int>>(1000);
auto copy = data; // reference count = 2

data.use_count(); // 2
// Deleted when last shared_ptr is destroyed

`std::weak_ptr` — Non-Owning Observer#

std::weak_ptr<User> observer = shared_user;
if (auto locked = observer.lock()) {
 // locked is a shared_ptr — object still alive
 locked->greet();
}
// If the object was deleted, lock() returns nullptr

When to Use What#

Type	Use
`unique_ptr`	Default. Single owner, deterministic destruction
`shared_ptr`	Multiple owners needed (rare — think carefully)
`weak_ptr`	Break reference cycles, caches, observers
Raw pointer	Non-owning reference (never `delete` a raw pointer)
Raw `new`/`delete`	Almost never. Only in allocator implementations

Move Semantics#

Move semantics transfer resources instead of copying them:

Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Concurrency#

C provides POSIX threads (pthreads). C++11 introduced a standard threading library with threads, mutexes, condition variables, futures, and atomics. C++20 added coroutines. This section covers both layers.

C Threads (pthreads)#

#include <pthread.h>

void *worker(void *arg) {
 int id = *(int *)arg;
 printf("Thread %d running\n", id);
 return NULL;
}

int main(void) {
 pthread_t threads[4];
 int ids[4] = {0, 1, 2, 3};

 for (int i = 0; i < 4; i++) {
 pthread_create(&threads[i], NULL, worker, &ids[i]);
 }
 for (int i = 0; i < 4; i++) {
 pthread_join(threads[i], NULL);
 }
 return 0;
}

gcc -pthread main.c -o app

pthreads Mutex#

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_lock(&lock);
// critical section
shared_counter++;
pthread_mutex_unlock(&lock);

C++ Threads (`<thread>`)#

#include <thread>
#include <iostream>

void worker(int id) {
 std::cout << "Thread " << id << " running" << std::endl;
}

int main() {
 std::thread t1(worker, 1);
 std::thread t2(worker, 2);

 t1.join(); // wait for t1
 t2.join(); // wait for t2

 // Or detach (run independently — use with caution)
 // t1.detach();
}

Lambda Threads#

int result = 0;
std::thread t([&result]() {
 result = expensive_computation();
});
t.join();

Mutexes#

#include <mutex>

std::mutex mtx;
int counter = 0;

void increment() {
 std::lock_guard<std::mutex> lock(mtx); // RAII — unlocks on scope exit
 counter++;
}

// C++17 with CTAD
void increment() {
 std::lock_guard lock(mtx); // type deduced
 counter++;
}

// unique_lock — more flexible (can unlock early, transfer ownership)
void process() {
 std::unique_lock lock(mtx);
 // ... critical section ...
 lock.unlock(); // release early
 // ... non-critical work ...
}

Multiple Mutexes (Avoiding Deadlock)#

std::mutex m1, m2;

void safe_swap() {
 std::scoped_lock lock(m1, m2); // C++17: locks both, deadlock-free
 // swap protected data
}

Atomics#

Lock-free operations on simple types:

Build Systems & Tooling

Mon, 01 Jan 0001 00:00:00 +0000

Build Systems & Tooling#

C and C++ have no standard build tool or package manager. The ecosystem relies on Make, CMake, and platform-specific tools. This section covers the build pipeline, debugging tools, sanitisers, and static analysis that make C/C++ development manageable.

Make#

The oldest and most universal build tool:

CC = gcc
CXX = g++
CFLAGS = -Wall -Wextra -Werror -std=c17 -g
CXXFLAGS = -Wall -Wextra -Werror -std=c++17 -g
LDFLAGS =

SRCS = main.c user.c database.c
OBJS = $(SRCS:.c=.o)
TARGET = app

.PHONY: all clean test

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^

%.o: %.c
	$(CC) $(CFLAGS) -c -o $@ $<

clean:
	rm -f $(OBJS) $(TARGET)

test: $(TARGET)
	./$(TARGET) --test

make # build
make clean # remove build artifacts
make -j$(nproc) # parallel build

CMake#

The de facto standard for cross-platform C/C++ projects:

C / C++ on Software Engineering Learning Paths

C Fundamentals

C Fundamentals#

Hello World#

Anatomy#

Compilation Pipeline#

Compiler Flags You Should Always Use#

Types#

Integer Types#

Pointers & Memory

Pointers & Memory#

What Is a Pointer?#

Stack vs Heap#

Dynamic Memory#

The Four Memory Bugs#

Pointer Arithmetic#

Strings & Arrays

Strings & Arrays#

C Strings#

String Length vs Array Size#

String Functions (<string.h>)#

Safe String Handling#

Structs & Unions

Structs & Unions#

Structs#

Typedef#

Structs with Pointers#

Memory Layout and Alignment#

The Preprocessor & Compilation

The Preprocessor & Compilation#

#include#

File I/O & System Calls

File I/O & System Calls#

Standard I/O (<stdio.h>)#

Opening and Closing Files#

Reading#

Writing#

Standard Streams#

POSIX I/O (Low-Level)#

C++ Core

C++ Core#

Classes#

Constructor Initialiser Lists#

C++ Object-Oriented

C++ Object-Oriented Programming#

Inheritance#

Key Rules#

Polymorphism#

Virtual Functions Internals#

Templates & STL

Templates & STL#

Function Templates#

Modern C++

Modern C++#

Smart Pointers#

std::unique_ptr — Exclusive Ownership#

std::shared_ptr — Shared Ownership#

std::weak_ptr — Non-Owning Observer#

When to Use What#

Move Semantics#

Concurrency

Concurrency#

C Threads (pthreads)#

pthreads Mutex#

C++ Threads (<thread>)#

Lambda Threads#

Mutexes#

Multiple Mutexes (Avoiding Deadlock)#

Atomics#

Build Systems & Tooling

Build Systems & Tooling#

Make#

CMake#

String Functions (`<string.h>`)#

Standard I/O (`<stdio.h>`)#

`std::unique_ptr` — Exclusive Ownership#

`std::shared_ptr` — Shared Ownership#

`std::weak_ptr` — Non-Owning Observer#

C++ Threads (`<thread>`)#