lectures-and-homeworks
lectures-and-homeworks copied to clipboard
📚 A place for all supplementary materials like slides, homework assignments etc.
Lectures and homeworks
This is a list of lectures from the C++ for yourself course.
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
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
Homework: 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,constexprwith variables - References to variables
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::mapandstd::unordered_map- Touch up on
std::setandstd::unordered_set
Homework: 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
Random number generation
Lecture script
- What are random numbers
- How to generate them in modern C++
- Why not to use
rand()
Homework: 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
lldbdebugger
Functions
Lecture script
- What is a function
- Declaration and definition
- Passing by reference
- Overloading
- Using default arguments
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
Homework: 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”
Const correctness
Lecture script
- What is const correctness
- Some rules and examples to follow in order to work with
constcorrectly
Homework: 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
FTXUIlibrary
- Read images from disk using
- 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
staticoutside of classes - Relation to storage duration
- Relation to linkage
- Why we should use
inlineinstead
Keyword static inside classes
Lecture script
- Using
staticclass methods - Using
staticclass data - What is
staticin 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
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!





























