C++ Programming — Tutorials

255Total chapters

28Modules

255Chapters live

28 / 28Active modules

Sequenced, not collected

Every concept arrives after its prerequisites. Pass-by-value before references, references and lifetime before pointers, manual new and delete before RAII, copy and move before smart pointers, templates before containers and algorithms, name mangling before extern "C". Nothing is explained with something you have not been taught yet.

Where C++ actually differs from C

The centre of gravity is object lifetime and resource management — constructors and destructors, RAII, copy and move semantics through the Rules of Three, Five and Zero, and smart pointers as ownership policies. These are the modules that decide whether C++ code is correct, and they are taught as one dependency chain rather than as idioms.

Two parts, one dependency chain

Part I is a complete C++ education that stands on its own for any learner. Part II is the semiconductor continuation — it builds on Part I and deliberately never re-teaches it, applying the same lifetime, ownership, representation and linkage facts to reference and golden models, scoreboard comparison, register and memory models, and SystemVerilog DPI end to end.

C++ Programming Complete Curriculum

Your Learning Roadmap

255 chapters · 28 modules — two parts — a complete modern C++ foundation, then the C++ a semiconductor engineer needs for reference models and SystemVerilog DPI.

255of 255 chapters live

100% complete

Part I — Proper C++ Programming

A complete C++ foundation with no hardware prerequisite, taught against a stated language baseline: how a program is built and run, types and initialization, expressions, control flow, functions, scope and namespaces, pointers and references, aggregates and strings, dynamic memory and the ownership question it raises, classes and invariants, constructors, destructors and RAII, copy and move semantics, smart pointers, inheritance and runtime polymorphism, templates and generic programming, the standard containers, iterators, algorithms and lambdas, the modern type and utility tools, error handling and exception safety, streams and data processing, build and project architecture, undefined behaviour and performance discipline, and concurrency fundamentals.

Module 1

Why C++ Matters in Semiconductor Engineering

1.1What C++ Is and What It Is Not 1.2Why C++ Exists and What Problem It Solves 1.3Which C++ Are We Learning: Standards, Compilers and Extensions 1.4C vs C++: What Carries Over and What Is Genuinely New 1.5Where C++ Is Used in Semiconductor Engineering 1.6C++ in a Verification Flow 1.7How a C++ Program Becomes a Running Program

Module 2

Building and Running C++ Programs

2.1The Structure of a C++ Program 2.2Your First C++ Program, Line by Line 2.3Compiling and Running from the Command Line 2.4Source Files and Header Files 2.5What the Preprocessor Does Before the Compiler 2.6Translation Units, Object Files and the Linker 2.7Reading Compiler and Linker Errors 2.8Printing Output While You Learn

Module 3

Types, Variables, and Initialization

3.1Objects, Variables and Types 3.2Fundamental Types and Their Sizes 3.3Integer Types, Signedness and Wraparound 3.4Fixed-Width Integer Types for Hardware Data 3.5Floating-Point Types and What They Cannot Represent 3.6bool and Character Types 3.7Initialization: The Forms and Which to Prefer 3.8Uninitialized Objects and Indeterminate Values 3.9const and Immutability 3.10auto and Type Deduction for Variables

Module 4

Expressions and Operators

4.1Expressions and Statements 4.2Arithmetic Operators and the Type of a Result 4.3Integer Division and Remainder 4.4Comparison and Equality Operators 4.5Logical Operators and Short-Circuit Evaluation 4.6Assignment and Compound Assignment 4.7Increment and Decrement 4.8Bitwise Operators and Shifts 4.9Precedence, Associativity and Evaluation Order 4.10Implicit Conversions and Explicit Casts

Module 5

Control Flow

5.1if, else and Multi-Way Decisions 5.2The Conditional Operator 5.3switch, Case Labels and Fallthrough 5.4while and do-while Loops 5.5for Loops 5.6Range-Based for Loops 5.7break, continue and Loop Correctness

Module 6

Functions

6.1Declarations, Definitions and Why Order Matters 6.2Parameters, Arguments and Pass-by-Value 6.3Return Values 6.4Passing by Reference 6.5const References and Cheap, Safe Parameters 6.6Default Arguments 6.7Function Overloading and Overload Resolution 6.8inline Functions and the One-Definition Rule 6.9Designing a Function Interface

Module 7

Scope, Storage, and Namespaces

7.1Scope: Where a Name Is Visible 7.2Lifetime and Scope Are Different Questions 7.3Storage Duration: Automatic, Static, Thread and Dynamic 7.4Static Objects and Their Initialization 7.5Internal Linkage: static at Namespace Scope and Anonymous Namespaces 7.6Namespaces: Declaring, Qualifying and Nesting 7.7using Declarations, using Directives and Name Collisions in Headers

Module 8

Pointers and References

8.1Addresses and What a Pointer Holds 8.2Address-of and Dereferencing 8.3nullptr and Checking Before You Dereference 8.4Pointer Arithmetic 8.5References: Binding, Aliasing and the Rules 8.6Pointers vs References: Choosing Between Them 8.7const Correctness with Pointers and References 8.8Dangling Pointers and Dangling References

Module 9

Arrays, Strings, and Aggregate Data

9.1Built-in Arrays: Contiguous Storage of One Type 9.2Array Decay and Array Parameters 9.3Multidimensional Arrays and Row-Major Layout 9.4C Strings and Null Termination 9.5std::string: Construction, Access and Modification 9.6std::string_view: Passing Text Without Copying 9.7struct: Grouping Data That Belongs Together 9.8Aggregate Initialization and Structure Layout 9.9Enumerations and enum class 9.10Structured Bindings 9.11Choosing a Representation for Engineering Data

Module 10

Dynamic Memory and Object Lifetime

10.1Why Dynamic Allocation Exists 10.2Automatic Storage and the Call Stack 10.3new and delete 10.4Dynamic Arrays: new[] and delete[]10.5Object Lifetime: When an Object Begins and Ends 10.6Memory Leaks 10.7Double Delete and Use-After-Free 10.8Why Manual delete Does Not Survive Real Control Flow 10.9Ownership: The Question new and delete Cannot Answer

Module 11

Classes and Encapsulation

11.1Why Classes Exist: Invariants, Not Just Grouping 11.2Defining a Class and Creating Objects 11.3Data Members and Member Functions 11.4Access Control: public, private and protected 11.5Encapsulation and the Class Invariant 11.6this and How a Member Function Finds Its Object 11.7const Member Functions and a const-Correct Interface 11.8static Members 11.9Designing a Class for Engineering Work

Module 12

Constructors and Destructors

12.1What Construction Actually Does 12.2Writing Constructors 12.3Member Initializer Lists 12.4Default, Defaulted and Deleted Constructors 12.5explicit and Unwanted Implicit Conversions 12.6Delegating Constructors 12.7Destructors 12.8Construction and Destruction Order 12.9RAII: Tying a Resource to an Object's Lifetime 12.10Reasoning About Lifetime in Real Code

Module 13

Copy and Move Semantics

13.1What Copying an Object Means 13.2The Copy Constructor 13.3Copy Assignment 13.4Shallow Copy, Deep Copy and the Double Free That Follows 13.5The Rule of Three 13.6Value Categories: lvalues, rvalues and Why They Matter Now 13.7Rvalue References 13.8Move Construction and Move Assignment 13.9std::move and the Moved-From State 13.10The Rule of Five 13.11The Rule of Zero and Why It Is the Goal 13.12Copy Elision and Returning Objects by Value

Module 14

Smart Pointers and Ownership

14.1Ownership as an API Decision 14.2std::unique_ptr: Exclusive Ownership 14.3Transferring Ownership with unique_ptr 14.4make_unique, Custom Deleters and Arrays 14.5std::shared_ptr and Reference Counting 14.6std::weak_ptr and Breaking Reference Cycles 14.7Raw Pointers in a Modern Codebase: Observers, Not Owners 14.8Designing Ownership-Aware Interfaces

Module 15

Operator Overloading

15.1What Operator Overloading Is For 15.2Member vs Non-Member Operators 15.3Arithmetic and Compound Assignment Operators 15.4Comparison Operators 15.5Stream Insertion and Extraction 15.6Assignment, Subscript and Function-Call Operators 15.7When Not to Overload an Operator

Module 16

Inheritance

16.1What Inheritance Models 16.2Base and Derived Classes 16.3public Inheritance and the Is-A Relationship 16.4protected Access and Who It Is Actually For 16.5Construction and Destruction Through a Hierarchy 16.6Name Hiding and Redeclaring a Member 16.7Composition vs Inheritance 16.8Inheritance Mistakes That Produce Fragile Hierarchies

Module 17

Runtime Polymorphism

17.1What Runtime Polymorphism Buys You 17.2virtual Functions and Dynamic Dispatch 17.3override and final 17.4Pure virtual Functions and Abstract Classes 17.5Virtual Destructors 17.6Object Slicing 17.7The Cost of Dispatch: Vtables as a Mental Model 17.8dynamic_cast and Runtime Type Identification 17.9Designing a Polymorphic Interface 17.10Consuming Polymorphic Interfaces

Module 18

Templates and Generic Programming

18.1The Problem Templates Solve 18.2Function Templates 18.3Template Argument Deduction 18.4Class Templates 18.5Non-Type Template Parameters 18.6Instantiation: When a Template Becomes Code 18.7Templates in Headers and the Errors They Produce 18.8Full and Partial Specialization 18.9Variadic Templates and Parameter Packs 18.10Generic Programming as a Design Approach

Module 19

Standard Library Containers

19.1What the Standard Containers Guarantee 19.2std::array and std::vector 19.3vector Growth, capacity and reserve 19.4std::deque and std::list 19.5std::map and std::set: Ordered Associative Containers 19.6std::unordered_map and std::unordered_set: Hashing 19.7Choosing a Container 19.8Container Performance and the Cost of the Wrong Choice

Module 20

Iterators, Algorithms, and Lambdas

20.1Iterators: The Interface Between Containers and Algorithms 20.2Iterator Categories and What Each Permits 20.3Iterator and Reference Invalidation 20.4The Algorithm Library and Why to Prefer It to a Loop 20.5Searching and Counting 20.6Sorting and Ordering 20.7Transforming and Accumulating 20.8Lambdas and Captures 20.9std::function and Storing a Callable 20.10Applying Algorithms to Engineering Data

Module 21

Modern C++ Type and Utility Tools

21.1Type Aliases: using and typedef 21.2constexpr: Computing at Compile Time 21.3decltype and Deduced Types in Interfaces 21.4std::pair and std::tuple 21.5std::optional: Representing No Value Honestly 21.6std::variant and std::any: One Object, Several Types 21.7Strong Types: Making Wrong Code Hard to Write 21.8Concepts and Constraining a Template

Module 22

Error Handling and Diagnostics

22.1Choosing an Error Strategy 22.2throw, try and catch 22.3Stack Unwinding and What Happens on the Way Out 22.4Exceptions and RAII 22.5Exception Safety Guarantees 22.6noexcept and Where an Exception Must Not Escape 22.7Error Codes and Result-Returning Interfaces 22.8assert and Checking Assumptions 22.9Logging and Diagnostics That Survive a Long Run

Module 23

Files, Streams, and Data Processing

23.1The Stream Model 23.2Formatted Output and Manipulators 23.3Reading Input and Handling Stream State 23.4File Streams: Opening, Reading, Closing 23.5String Streams and In-Memory Formatting 23.6Binary Files and Byte-Level Layout 23.7Parsing Simulation Logs and Reports 23.8Test Vectors and Machine-Readable Results

Module 24

C++ Build and Project Architecture

24.1Translation Units and the One-Definition Rule 24.2What Belongs in a Header and What Belongs in a Source File 24.3Include Guards and #pragma once 24.4Forward Declarations and Compile-Time Dependencies 24.5Name Mangling and C++ Linkage 24.6Static and Shared Libraries 24.7Warnings, Standard Flags and Debug vs Optimized Builds 24.8CMake Fundamentals 24.9Organizing a C++ Engineering Project

Module 25

Debugging, Undefined Behavior, and Performance

25.1Undefined Behavior in C++25.2Uninitialized Data and Indeterminate Values 25.3Out-of-Bounds Access 25.4Lifetime Failures: Dangling, Use-After-Free and Invalidated Iterators 25.5Debugging with a Method, Not a Reflex 25.6Sanitizers 25.7Memory Debugging Tools 25.8Profiling: Measuring Before Optimizing 25.9Hidden Copies and Allocations 25.10Disciplined Optimization

Module 26

Concurrency Fundamentals

26.1Why Concurrency Appears in Engineering Code 26.2std::thread: Starting, Joining and Detaching 26.3Shared State and Data Races 26.4std::mutex and Lock Guards 26.5Deadlock and Lock Ordering 26.6Condition Variables 26.7Atomics 26.8Memory Ordering as a Mental Model 26.9Debugging Concurrent Code

Part II — C++ for Semiconductor Verification & DPI

The C++ a semiconductor engineer needs, built on Part I and never repeating it: C++ in a verification stack — transaction, reference, golden, register and memory models, stimulus and test-vector generation, scoreboard-style comparison and protocol data modeling — and then the SystemVerilog boundary end to end, from why DPI exists and C versus C++ linkage through extern "C", scalar, array, open-array and string crossing, pure and context imports, boundary debugging, and integrating a complete C++ reference model with a testbench.

Module 27

C++ for Semiconductor Verification

27.1Where C++ Appears in a Verification Stack 27.2Modeling a Transaction in C++27.3Reference Models: What They Must Guarantee 27.4Golden Models and Independence from the RTL 27.5Generating Stimulus and Test Vectors in C++27.6Scoreboard-Style Comparison and Mismatch Reporting 27.7Register Models in C++27.8Memory Models in C++27.9Modeling Protocol Data: Fields, Packing and Byte Order 27.10C++ or SystemVerilog: Deciding Where a Job Belongs 27.11Building a Small Reference Model End to End

Module 28

C/C++ and SystemVerilog DPI

28.1Why DPI Exists 28.2The DPI Architecture: Two Languages, One Process 28.3Importing a C or C++ Function into SystemVerilog 28.4Exporting a SystemVerilog Function to C 28.5C Linkage vs C++ Linkage Across the Boundary 28.6extern "C" and Why a C++ Reference Model Needs It 28.7Scalar Type Mapping 28.8Arrays Across the Boundary 28.9Open Arrays and the Open Array API 28.10Strings Across the Boundary 28.11Pure and Context Imports 28.12Boundary Failures and How to Debug Them 28.13Integrating a C++ Reference Model with SystemVerilog