Lectures and projects for the C++ for yourself course

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.

💡 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

PS

Most of the code snippets are validated automatically

If you do find an error in some of those, please open an issue in this repo!