This open-access course is directed at those who are already familiar with C and object-oriented programming towards a proficiency level of C++ programming. The course covers the basics of C++ programming and moves on to advanced C++ semantics and concepts.
Key features:
- Free and frequently updated
- 22 lectures, ~1500 slides
- Include the last language standard concepts and features
- Practical teaching: non-verbose, short structured descriptions associated with code
- Minimal code examples for showing just a specific feature or issue without digressing
- Complementary language aspects: tools, coding conventions, project organization, and code optimization
- Experience-based: many aspects, examples, and problems come from real-world cases faced during my work as software engineer
If you enjoy the course or you find it useful, please add a Star
| # | TITLE | MAIN FOCUS |
|---|---|---|
| 1 | Introduction | History of C/C++, Areas of Applications, Course introduction |
| 2 | Basic Concepts I - Fundamental Types | Types overview, operators, and conversion |
| 3 | Basic Concepts II - Integral and Floating-point Types | Integral and floating-point types and their arithmetic |
| 4 | Basic Concepts III - Entities and Control Flow | Enumerators, structures, control flow statements |
| 5 | Basic Concepts IV - Memory Management | Heap, Stack, pointers, references, const properties, conversion operators |
| 6 | Basic Concepts V - Functions and Preprocessing | Functions, lambda expressions, preprocessing directives |
| 7 | Object Oriented Programming I - Class Concepts | Class hierarchy, constructor, destructor, class keywords |
| 8 | Object Oriented Programming II - Polymorphism and Operator Overloading | Polymorphism, operators overloading |
| 9 | Templates and Meta-programming I - Function Templates and Compile-Time Utilities | Function template, type traits |
| 10 | Templates and Meta-programming II - Class Templates and SFINAE | Class template, SFINAE |
| 11 | Translation Units I | Linkage and One Definition Rule |
| 12 | Translation Units II | Dealing with multiple translation units and files, #include, and modules |
| 13 | Code Conventions | Project organization and main code conventions |
| 14 | Ecosystem I | Debugging, and testing |
| 15 | Ecosystem II | Cmake, documenting, and other Tools |
| 16 | Utilities | Main std libraries |
| 17 | Containers, Iterators, and Algorithms | Containers, iterators, algorithms, ranges |
| 18 | Advanced Topics I | Move semantics, universal reference, type deduction |
| 19 | Advanced Topics II | Error handling, C++ idioms, smart pointers |
| 20 | Optimization I - Basic Concepts | Ahmdal Law, performance bounds, architecture concepts (ILP, SIMD, etc.), memory hierarchy |
| 21 | Optimization II - Code Optimization | Arithmetic optimizations, memory optimizations, etc. |
| 22 | Optimization III - Non-Coding Optimizations and Benchmarking | Compiler optimizations, profiling and benchmarking tools |
ALL-IN-ONE BOOK: modern-cpp.pdf (could be a few commits behind)
- A Little History of C/C++ Programming Languages
- Areas of Application and Popularity
- C++ Philosophy
- C++ Weakness
- Books and References
- The Course
2. Basic Concepts I - Fundamental Types and Operations
- Preparation: What compiler should I use?, What editor/IDE compiler should I use?, How to compile?
- Hello World: I/O Stream
- C++ Fundamental Types Overview: Arithmetic types, Non-standard arithmetic types,
voidtype, Pointer type andnullptr - Conversion Rules
autodeclaration- C++ Operators: Operators precedence, Prefix/Postfix increment/decrement, Assignment, Compound , and Comma operators, Spaceship operator
<=>, Safe Comparison Operators
3. Basic Concepts II - Integral and Floating-point Types
- Integral Data Types: Fixed width integers,
size_tandptrdiff_t, Signed/Unsigned integer characteristics, Promotion, Truncation, Undefined behavior - Floating-point Types and Arithmetic: IEEE Floating-point Standard and Other Representations, Normal/Denormal values, Infinity, Not a Number (
NaN), Machine Epsilon, Units at the Last Place (ULP), Cheatsheet, Summary, Arithmetic Properties, Detect Floating-point Errors - Floating-point Issues: Catastrophic cancellation, Floating-point comparison
4. Basic Concepts III - Entities and Control Flow
- Entities
- Declaration and Definition
- Enumerators
struct, Bitfield,union- Control Flow:
ifStatement,forLoop, Range-baseforloop,switch,goto, Avoid unused variable warning[[maybe unused]]
5. Basic Concepts IV - Memory Concepts
- Heap and Stack: Stack Memory,
new,delete, Non-allocating placement allocation, Non-throwing allocation, Memory leak - Initialization: Variable initialization, Uniform initialization, Fixed-size array initialization, Structure initialization, Dynamic memory initialization
- Pointers and References: Pointer Operations, Address-of operator
&, Reference - Constant and Literals,
const,constexpr,consteval,constinit,if constexpr,std::is constant evaluated(),if consteval volatilekeyword- Explicit Type Conversion:
static_cast,const_cast,reinterpret_cast, Type punning sizeofOperator
6. Basic Concepts V - Functions and Preprocessing
- Functions: Pass by-value, Pass by-pointer, Pass by-reference, Function signature and Overloading, Overloading and
=delete, Default parameters, Attributes[[attributes]] - Function Pointer and Function Objects
- Lambda Expressions: Capture list, Parameters, Composability,
constexpr/consteval,template,mutable,[[nodiscard]], Capture list and classes - Preprocessing: Preprocessors, Common errors, Source location macros, Conditional compiling macros, Stringizing operator (
#),#errorandwarning,#pragma, Token-Pasting Operator (##), Variadic Macro
7. Object-Oriented Programming I - Class Concepts
- C++ Classes: RAII Idiom
- Class Hierarchy
- Access specifiers: Inheritance access specifiers, When use
public/protected/privatefor data members? - Class Constructor: Default constructor, Class initialization, Uniform initialization for objects, Delegate constructor,
explicitkeyword,[[nodiscard]]and classes - Copy Constructor
- Class Destructor
- Defaulted Constructors, Destructor, and Operators (
= default) - Class Keywords:
this,static,const,mutable,using,friend,delete
8. Object-Oriented Programming II - Polymorphism and Operator Overloading
- Polymorphism:
virtualmethods, Virtual table,overridekeyword,finalkeyword, Common errors, Pure virtual method, Abstract class and interface - Inheritance Casting and Run-time Type Identification
- Operator Overloading: Overview, Comparison operator
<, Spaceship operator<=>, Subscript operator[], Multidimensional Subscript operator[], Function call operator(), static operator[]and operator(), Conversion operatorT(), Return type overloading resolution, Increment and decrement operators++/--, Assignment operator=, Stream operator<<, Operator Notes - C++ Special Objects: Aggregate, Trivial class, Standard-layout class, Plain old data (POD), Hierarchy
9. Templates and Meta-programming I - Function Templates and Compile-Time Utilities
- Function Template: Overview, Template parameters, Template parameter - default value, Overloading, Specialization
- Template Variable
- Template Parameter Types: Generic Type Notes,
autoPlaceholder, Class template parameter type, Array and pointer types, Function type - Compile-Time Utilities:
static_assert,decltypeKeyword,usingKeyword - Type Traits: Overview, Type traits library, Type manipulation
10. Templates and Meta-programming II - Class Templates and SFINAE
- Class Template: Class specialization, Class template constructor, Constructor template automatic deduction (CTAD)
- Class Template - Advanced Concepts: Class + Function - Specialization, Dependent Names -
typenameandtemplateKeywords, Class template hierarchy andusing,friendKeyword, Template Template Arguments - Template Meta-Programming
- SFINAE: Substitution Failure Is Not An Error: Function SFINAE, Class SFINAE, Class + Function SFINAE
- Variadic Template: Folding Expression, Variadic class template
- C++20 Concepts: Overview,
conceptKeyword,requiresClause,requiresExpression,requiresExpression + Clause,requiresClause + Expression,requiresandconstexpr, Nestedrequires
11. Translation Units I - Linkage and One Definition Rule
- Basic Concepts: Translation unit, Local and global scope, Linkage
- Storage Class and Duration: Storage duration, Storage class,
staticandexternkeywords, Internal/External linkage examples - Linkage of
constandconstexpr: Static Initialization Order Fiasco - Linkage Summary
- Dealing with Multiple Translation Units: Class in multiple translation units
- One Definition Rule (ODR): Global variable issues, ODR - Point 3,
inlinefunctions/variables,constexprandinline - ODR - Function Template: Cases,
externkeyword - ODR - Class Template: Cases,
externkeyword - ODR Undefined Behavior and Summary
12. Translation Units II - Include, Module, and Namespace
#includeIssues: Forward declaration, Include guard, Circular dependencies, Common linking errors- C++20 Modules: Overview, Terminology, Visibility and Reachability, Module unit types, Keywords, Global module fragment, Private module fragment, Header module unit, Module partitions
- Namespace: Namespace functions vs.
staticmethods, Namespace alias, Anonymous namespace,inlinenamespace, Attributes and namespace - Compiling Multiple Translation Units: Fundamental compiler flags, Compile Methods, Deal with libraries, Build static/dynamic libraries, Find dynamic library dependencies, Analyze object/executable symbols
- C++ Project Organization: Project directories, Project files, “Common” Project Organization Notes, Alternative - “Canonical” project organization
- Coding Styles and Conventions
#include- Macro and Preprocessing
- Namespace
- Variables and Arithmetic Types
- Functions
- Structs and Classes
- Control Flow
- Modern C++ Features
- Maintainability
- Naming
- Readability and Formatting
- Code Documentation
- Debugging
- Assertion
- Execution debugging: Breakpoints, Watchpoints / Catchpoints, Control Flow, Stack and Info, Print, Disassemble
- Memory Debugging:
valgrind, Stack protection - Sanitizers: Address sanitizer, Leak sanitizer, Memory sanitizers, Undefined behavior sanitizer
- Debugging Summary
- Compiler Warnings
- Static Analysis
- Code Testing: Unit test, Test-Driven Development (TDD), Code coverage, Fuzz testing
- Code Quality:
clang-tidy
15. Ecosystem II - Cmake and Other Tools
- CMake:
cmakeandctest - Code Documentation:
doxygen - Code Statistics: Count lines of code, Cyclomatic complexity analyzer
- Other Tools: Code formatting -
clang-format,Compiler Explorer, Code transformation -CppInsights, Code autocompletion -GitHub Co-Pilot/TabNine/Kite, Local code search -ripgrep, Code search engine -searchcode/grep.app, Code benchmarking -Quick-Bench, Font for Coding
- I/O Stream: Manipulator,
ofstream/ifstream - Strings:
std::string, Conversion from/to numeric values,std::string_view,std::format,std::print - Math Libraries
- Random Number: Basic Concepts, C++
<random>, Seed, PRNG period and quality, Distribution, Quasi-random - Time Measuring: Wall-Clock time, User time, System time
- Std Class Templates:
std::pair,std::tuple,std::variant,std::optional,std::any,std::stacktrace - Filesystem Library: Query methods, Modify methods
17. Containers, Iterators, and Algorithms
- Containers and Iterators
- Sequence Containers:
std::array,std::vector,std::list,std::deque,std::forward_list - Associative Containers:
std::set,std::map,std::multiset - Container Adaptors:
std::stack,std::queue,std::priority_queue - View:
std::span - Implement a Custom Iterator: Semantic, Implement a simple Iterator
- Iterator Utility Methods:
std::advance,std::next,std::prev,std::distance, Container access methods, Iterator traits - Algorithms Library:
std::find_if,std::sort,std::accumulate,std::generate,std::remove_if - C++20 Ranges: Key concepts, Range view, Range adaptor, Range factory, Range algorithms, Range actions
- Move Semantic:
lvaluesandrvaluesreferences, Move semantic,std::move, Class Declaration Semantic - Universal Reference and Perfect Forwarding: Universal reference, Reference collapsing rules, Perfect forwarding
- Value Categories
&,&&Ref-qualifiers andvolatileOverloading- Copy Elision and RVO
- Type Deduction: Pass by-reference, Pass by-pointer, Pass by-value,
autodeduction constCorrectness
- Undefined Behavior: Common cases, Detecting undefined behavior
- Error Handling: C++ Exceptions, Defining custom exceptions,
noexceptkeyword, Memory allocation issues, Alternative error handling approaches - C++ Idioms: Rule of zero/three/five, Singleton, PIMPL, CRTP, Template Virtual Functions
- Smart pointers:
std::unique_ptr,std::shared_ptr,std::weak_ptr - Concurrency: Thread Methods, Mutex, Atomic, Task-based parallelism
20. Optimization I - Basic Concepts
- Introduction: Moore’s Law, Moore’s Law limitations, Reasons for Optimizing
- Basic Concepts: Asymptotic complexity, Time-Memory Trade-off, Developing Cycle, Ahmdal's law, Throughput, Bandwidth, Latency, Performance bounds, Arithmetic intensity
- Basic Architecture Concepts: Instruction-level parallelism (ILP), Little’s law, Data-level parallelism (SIMD), Thread-level parallelism (TLP), Single Instruction Multiple Threads (SIMT), RISC, CISC Instruction sets
- Memory Hierarchy: Memory hierarchy concepts, Memory locality
21. Optimization II - Code Optimization
- I/O Operations:
printf, Memory mapped I/O, Speed up raw data loading - Memory Optimizations: Heap memory, Stack memory, Cache utilization, data alignment, Memory Prefetch
- Arithmetic: Data types, Operations, Conversion, Floating-point, Compiler intrinsic functions, Value in a range, Lookup table
- Control Flow: Loop hoisting, Loop unrolling, Branch hints
[[likely/unlikely]], Compiler hints[[assume]], Recursion - Functions: Function call cost, Argument passing, Function optimizations, Function inlining, Pointers aliasing
- Object-Oriented Programming
- Std Library and Other Language Aspects
22. Optimization III - Non-Coding Optimizations and Benchmarking
- Compiler Optimizations: About the compiler, Compiler optimization flags, Linker optimization flags, Architecture flags, Help the Compiler to produce better code, Profile guided optimization (PGO), Post-Processing Binary Optimizer
- Compiler Transformation Techniques: Basic Transformations, Loop unswitching, Loop fusion, Loop fission, Loop interchange, Loop tiling
- Libraries and Data Structures: External libraries
- Performance Benchmarking: What to test?, Workload/Dataset quality, Cache behavior, Stable CPU performance, Program, Multi-threads considerations, Program memory layout, Measurement overhead, Compiler optimizations, Metric evaluation
- Profiling:
gprof,uftrace,callgrind,cachegrind,perfLinux profiler - Parallel Computing: Concurrency vs. Parallelism, Performance scaling, Gustafson’s Law, Parallel programming languages
- Software Design Chapter
- Build Aspects Chapter (e.g. reducing build time)
Online compiler and execution: CompilerExplorer
- for code execution: [Add new..] -> [execution only]
If you find any typo, conceptual error, or section to improve, please report them by using the issue panel.
Federico Busato
- Twitter: twitter.com/fedebusato
- LinkedIn: www.linkedin.com/in/federico-busato/