C & C++ Tutorial Overview: From the First Line of Code to Systems Engineering

This track is designed for readers with absolutely no prior background in C or C++. We don't start with ABI, vtables, and memory models. Instead, we begin by exploring what C/C++ actually are, where the code lives, how it is compiled and executed, and the specific role every symbol plays in your program. However, this is not a shallow syntax reference. Every foundational concept will be traced all the way down to the compiler, memory layout, lifecycle, linker, and associated engineering risks.

Learning Roadmap

01 Getting Started
  -> 02 C Language Core Syntax
  -> 03 C Data and Memory Representation
  -> 04 C Systems Engineering Foundations
  -> 05 C++ Basics and Object Models
  -> 06 Modern C++ and the Standard Library
  -> 07 Concurrency Safety and Engineering

The first stage resolves the fundamental questions: "How do I write, execute, and debug?" The second stage establishes the lexical structure of C, variables, types, expressions, control flow, functions, and headers. The third stage dives into arrays, strings, structs, enums, pointers, object representation, storage duration, and ownership. The fourth stage connects source files, the preprocessor, dynamic memory, file I/O, compilation, linking, and undefined behavior (UB). The fifth stage transitions into C++: namespaces, references, overloading, classes, constructors/destructors, inheritance, polymorphism, and virtual functions. The sixth stage explores modern C++: RAII, move semantics, standard library containers, ranges, templates, Concepts, and constexpr. The seventh stage tackles concurrency, thread safety, sanitizers, CMake, CI pipelines, and release auditing.

The Relationship Between C and C++

C is a language that operates incredibly close to the bare machine model. It forces you to explicitly control object representation, memory addresses, storage duration, function invocations, and resource deallocation. C++ retains this low-level access path while introducing object lifecycles, RAII, generic programming, a robust standard library, and powerful zero-cost abstractions.

C: Bytes, addresses, functions, structs, explicit resource management.
C++: Objects, lifecycles, advanced type systems, generics, zero-cost abstractions.
Shared Foundations: Compilers, linkers, ABI, memory models, threading, toolchains.

Therefore, this tutorial will not teach C++ merely as "C with classes." Nor will it treat C as an "outdated C++." They share a toolchain, but their underlying philosophies and mental models are fundamentally distinct.

Reading Criteria for Each Article

When reading each article, do not limit yourself to asking "how do I write this syntax." You must also ask:

• What specific engineering problem does this syntax solve?
• How does the compiler interpret and lower it?
• What physical layout does it leave behind in memory?
• Will error paths cause resource leaks?
• Does this break concurrency boundaries in a multi-threaded environment?
• Do the implicit contracts hold true across file, library, and platform boundaries?

Current Standards Context

The C curriculum is contextualized against C23 as the baseline standard, while explicitly addressing the long-term engineering reality of C11/C17. The C++ curriculum treats C++23 as the current production-ready baseline, framing C++26 as an evolutionary direction rather than the default production standard. Because compilers, standard libraries, and platform ABIs implement standards at different paces, this tutorial continuously distinguishes between "what the standard permits" and "what is currently viable in production engineering."

Ultimate Capability Goals

Upon completing this track, you will be able to write small C/C++ programs from scratch and precisely articulate how they are compiled, linked, and executed. You will effortlessly read and comprehend pointers, arrays, structs, classes, objects, templates, and standard containers. More importantly, you will develop the engineering intuition to identify undefined behavior, dangling pointers, iterator invalidation, data races, ABI incompatibilities, and resource leaks.

The ultimate goal of ZeroBug is not to write code that "just barely works," but to ensure that every boundary in your program is supported by evidence, constraints, observability, and rollback capabilities.