cpp-for-yourself/lectures-and-homeworks

cpp-for-yourself/lectures-and-homeworks has 432 GitHub stars and 46 forks. GitHot measured 0 stars in 24 hours and 0 in 7 days. Last checked 2026-11-09 15:54 UTC. Last push 2026-09-03.

How these counts are measured

📚 A place for all lecture scripts, projects etc. for the "C++ for yourself" course

432 stars 46 forks

Measured star growth

in 24h: 0
in 7 days: 0
in 15 days: Collecting history
in 1 month: Collecting history

Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.

README.md

Original

Lectures and projects for the C++ for yourself course

Visitors

This repository is a collection of Markdown scripts used for all the videos in the C++ for yourself course.

These can be used to follow-along the video or as a standalone learning material.

🙏 Support this work

Please remember that there is a human behind all of this work. I write scripts, create animations, record and edit videos at night after a full-time work day. It is at times hard. But you can make it easier. Here is what you can do:

💶 Become a sponsor on GitHub!
💸 Can't support monetarily?
- 👍 Like the videos and watch them to the end!
- 💬 Leave comments on YouTube!
- 📢 Spread the word among your friends!
- ⭐️ Star the repo to help others find it!
🤬 Don't like something? 🗣️ Talk to me about it! I am always eager to improve.

:bulb: How to follow this course

The course is designed to be consumed from top to bottom, so start at the beginning and you will always have enough knowledge for the next video.

That being said, I aim to leave links in the videos so that one could watch them out of order without much hassle.

Enjoy! 😎

📕 C++ for yourself lectures

Hello World program in C++	Hello world program dissection Lecture script First keywords What brackets mean What do different signs mean Intro to "scopes" Intro to functions Intro to includes
`Project`: hello world program Homework script Write a simple program that prints `Hello World!` Learn to compile and run simple programs	Variables of fundamental types Lecture script How to create variables of fundamental types Naming variables Using `const`, `constexpr` with variables References to variables
Namespaces for variables Lecture script Namespaces with variables The word `using` with variables	Input/output streams Lecture script `std::cout`, `std::cerr`, `std::cin`
Sequence and utility containers Lecture script Sequence containers: `std::array`, `std::vector`, their usage and some caveats Pair container: `std::pair` Strings from STL: `std::string` Conversion to/from strings: `to_string`, `stoi`, `stod`, `stof`, etc. Aggregate initialization	Associative containers Lecture script `std::map` and `std::unordered_map` Touch up on `std::set` and `std::unordered_set`
`Project`: fortune teller program Homework script Write a program that tells your C++ fortune It reads and writes data from and to terminal Stores and accesses these data in containers	Control structures Lecture script `if`, `switch` and ternary operator `for`, `while` and `do ... while`
Random number generation Lecture script What are random numbers How to generate them in modern C++ Why not to use `rand()`	`Project`: the guessing game Homework script A program that generates a number The user guesses this number The program tells the user if they are above or below with their guess (or if they've won)
Compilation flags and debugging Lecture script Useful compilation flags Debugging a program with: Print statements `lldb` debugger	Functions Lecture script What is a function Declaration and definition Passing by reference Overloading Using default arguments
Enumerations Lecture script What are `enums` How to use them? Why not to use old style `enums`	Libraries and header files Lecture script Different types of libraries Header-only Static Dynamic What is linking When to use the keyword `inline` Some common best practices
Build systems introduction Lecture script Intro to build systems Build commands as a script Build commands in a `Makefile`	CMake introduction Lecture script Build process with CMake CMake Variables Targets and their properties Example CMake project
Using GoogleTest framework for testing code Lecture script Explain what testing is for Explain what testing is Show how to download and setup googletest Show how to write a simple test	Installing projects and using `find_project` with CMake Disclaimer What does `find_package` do? Search modes Module mode Config mode How do the config files look like? What are the export files? Summary of reusing targets How to make `core_project` available to `dependent_project` Project skeleton for `core_project` Installing a package 1. Copying headers 2. Copying binaries 3. Creating export files 4. Creating config files How to use the installed package Summary
`Project`: string processing library Homework script You will write library that allows to split and trim strings You will learn how to: Write a CMake project from scratch Write your own libraries Test them with googletest Link them to binaries	Simple custom types with classes and structs Lecture script Explain why the classes are needed Implement an example game about a car Define classes and structs more formally
Raw pointers Lecture script The pointer type Pointers = variables of pointer types How to get the data? Initialization and assignment Using const with pointers Non-const pointer to const data Constant pointer to non-const data Constant pointer to constant data	Object lifecycle Lecture script Creating a new object What happens when an object dies Full class lifecycle explained
Move semantics Lecture script Why we care about move semantics Let’s re-design move semantics from scratch How is it actually designed and called in Modern C++?	Constructors, operators, destructor - rule of all or nothing Lecture script “Good style” as our guide What is “good style” Setting up the example Rule 1: destructor Rule 2: copy constructor Rule 3: copy assignment operator Rule 4: move constructor Rule 5: move assignment operator Now we (mostly) follow best practices Rule of 5 (and 3) The rule of “all or nothing”
Headers with classes Lecture script What stays the same What is different Example to show it all	Const correctness Lecture script What is const correctness Some rules and examples to follow in order to work with `const` correctly
`Project`: pixelate images in terminal Homework script You will write a library that allows to pixelate an image You will learn how to: Work with classes Use external libraries Read images from disk using `stb_image.h` Draw stuff in the terminal using `FTXUI` library Manage memory allocated elsewhere correctly Writing multiple libraries and binaries and linking them together Manage a larger CMake project	Keyword `static` outside of classes Lecture script Why we should not use `static` outside of classes Relation to storage duration Relation to linkage Why we should use `inline` instead
Keyword `static` inside classes Lecture script Using `static` class methods Using `static` class data What is `static` in classes useful for?	Templates: why would we want to use them? Lecture script Templates provide abstraction and separation of concerns Function templates Class and struct templates Generic algorithms and design patterns Zero runtime cost (almost) Compile-time meta-programming Summary
Templates: what do they do under the hood? Lecture script Compilation process recap Compiler uses templates to generate code Hands-on example Compiler is lazy	How to write function templates Lecture script The basics of writing a function template Explicit template parameters Implicit template parameters Using both explicit and implicit template parameters at the same time Function overloading and templates Full function template specialization and why function overloading is better
How to write class templates How to use templates with classes in C++ Class method templates Prefer overloading to specialization of class method templates Sometimes overloading is not possible --- specialize in this case Class templates Class template argument deduction (min. C++17) Class template specialization: implicit and explicit Full explicit template specialization How to fully specialize class templates Make sure a specialization follows the expected interface Historical reference for `std::vector<bool>` Specialize just one method of a class Specialize method templates of class templates Type traits and how to implement them using template specialization More generic traits using partial specialization Difference between partial and full specializations How to tell partial template specialization apart from a new template class definition? How to tell a partial template specialization apart from a full class template specialization? Partial template specialization with more types Summary	Forwarding references The forwarding reference Why use forwarding references Example setup How forwarding references simplify things When to prefer forwarding references How forwarding references work Reference collapsing Remove reference using `std::remove_reference_t` How `std::forward` works Passing an lvalue Passing by rvalue Summary
Header and source files for templated code Why linker fails Compilation process for single `main.cpp` file Compilation process for multiple files How to fix the linker error More complex explicit instantiations Summary	Almost everything about inheritance Inheritance enables dependency inversion The idea behind dependency inversion Similarity to static polymorphism with templates How inheritance looks in C++ Implementation inheritance Access control with inheritance Implicit upcasting Real-world example of implementation inheritance Using `virtual` for interface inheritance and proper polymorphism How interface inheritance works Runtime and memory overhead of using virtual Things to know about classes with `virtual` methods A `virtual` destructor Delete other special methods for polymorphic classes Downcasting using the `dynamic_cast` Don't mix implementation and interface inheritance Implement pure interfaces Keyword `final` Simple polymorphic class example following best practices Multiple inheritance Detailed `Image` example following best practices
Memory management and smart pointers Memory management and smart pointers Memory management in C++ Automatic memory management in other programming languages The C++ way Memory allocation under the hood The stack Why not keep persistent data on the stack The heap Operators `new` and `delete` Typical pitfalls with data allocated on the heap Forgetting to call `delete` Performing shallow copy by mistake Performing shallow assignment by mistake Calling a wrong `delete` Returning owning pointers from functions RAII for memory safety STL classes use RAII Smart pointers to the rescue! `std::unique_ptr` `std::shared_ptr` Prefer `std::unique_ptr` Smart pointers are polymorphic Summary	Lambdas in modern C++ Lambdas Overview What is a "callable" A function pointer is sometimes enough Before lambdas we had function objects (or functors) How to implement generic algorithms like `std::sort` Enter lambdas Lambda syntax When to use lambdas Summary
Error handling in C++ Disclaimer What Do We Mean by “Error”? Setting up the example: a comparison game Rules of the game Initial code of the game Unrecoverable errors: fail early Our first unrecoverable error encounter How to deal with unrecoverable errors Catch them as early as possible Use `CHECK` macro to fail early Don't use `assert` Complete the `Game` class yourself How to minimize number of unrecoverable errors Recoverable errors: handle and proceed Exceptions How to use exceptions A case for exceptions for both "recoverable" and "unrecoverable" errors Why we might not want to use exceptions Exceptions are (sometimes) expensive Exceptions hide the error path Exceptions are banned in many code bases Returning errors explicitly can work better if done well Returning a value indicating error does not always work 😱 Returning an error code breaks "pure functions" 😱 Using `std::optional`: a better way Using `std::expected`: add context Performance Considerations for `std::optional` and `std::expected` Error type size matters Return value optimization with `std::optional` and `std::expected` Summary Other use of `std::optional`	Dynamic polymorphism with `std::variant` `std::variant` in Modern C++ Templates (and concepts) allow static polymorphism Until now dynamic polymorphism required reference semantics Use `std::variant` for dynamic polymorphism with value semantics Basics of `std::variant` Memory used by `std::variant` Use `std::monostate` to allow for "empty" variants Storing values in a `std::variant` Using `std::variant` with `std::visit` How `std::visit` selects the correct function Visitor must cover all variant types Back to the original example Summary
Storing callables with `std::function` `std::function` Overview The problem: storing callables Enter `std::function` Performance considerations Type erasure (how it works under the hood) Summary	Parallelism in modern C++ Parallelism in modern C++ Disclaimer What is parallelism anyway? No parallelism is always safer and often faster High-level Task-Based Parallelism Execution Strategies (`std::launch`) Parallel Algorithms Execution Policies (`std::execution`) Raw TBB Parallelism Worker threads and thread pools Step 1: How to create a thread Stopping threads cooperatively with `std::stop_token` Step 2: Adding another thread and a Mutex Step 3: Sleeping with Condition Variables Optimizing by Swapping the Queue Step 4: Putting it all together into a Generic Thread Pool What if I don't have C++20? Deadlocks Summary