C++ Programming Course - Beginner to Advanced

Brief Summary

This video is a complete C++ course for beginners. It covers fundamental concepts like variables, data types, operators, statements, functions, and loops. The course also delves into object-oriented programming concepts like classes, inheritance, and polymorphism. The video emphasizes the importance of understanding the C++ memory model and execution model, as well as the use of tools like compilers, IDEs, and debuggers.

• Learn the fundamentals of C++ programming.
• Explore object-oriented programming concepts.
• Understand the C++ memory model and execution model.
• Learn how to use tools like compilers, IDEs, and debuggers.

Introduction

This video introduces a modern C++ course for beginners. It covers the basics of C++ programming, including procedural programming, object-oriented programming, and advanced features. The course is designed for complete beginners and emphasizes understanding the fundamentals.

Development Tools

This chapter explains the essential tools for C++ development, including editors/IDEs and compilers. The video recommends using Visual Studio Code as the editor for its ease of use, cross-platform compatibility, and support for various tools. It also discusses the role of compilers in transforming C++ code into executable binary formats. The chapter provides detailed instructions on installing Visual Studio Code and various compilers (GCC, Clang, and MSVC) on Windows, Linux, and macOS.

Connecting Visual Studio Code to Compilers

This chapter focuses on connecting Visual Studio Code to the previously installed compilers. It demonstrates how to configure Visual Studio Code to use GCC, Clang, and MSVC compilers for building C++ projects. The chapter uses a simple C++ program to test the compiler's support for C++20 features and provides a template project that can be reused throughout the course.

Compilers on Linux

This chapter covers the installation of C++ compilers on Linux, specifically Ubuntu 20.04. It explains how to install GCC 10 and Clang LLVM using the apt package manager. The chapter also discusses the use of Homebrew for installing the latest version of GCC on Linux.

Visual Studio Code on Linux

This chapter focuses on installing Visual Studio Code on Linux (Ubuntu 20.04). It provides instructions on downloading the Visual Studio Code binary and installing it using the dpkg package manager. The chapter also explains how to install the C/C++ extension for Visual Studio Code on Linux.

Connecting Visual Studio Code to Compilers on Linux

This chapter demonstrates how to connect Visual Studio Code to the previously installed compilers on Linux. It shows how to configure Visual Studio Code to use GCC and Clang compilers for building C++ projects on Ubuntu 20.04. The chapter uses a simple C++ program to test the compiler's support for C++20 features and provides a template project that can be reused throughout the course.

Compilers on macOS

This chapter covers the installation of C++ compilers on macOS. It explains how to install GCC and Clang LLVM using the Homebrew package manager. The chapter also discusses the installation of Xcode and its associated compiler for C++ development on macOS.

Visual Studio Code on macOS

This chapter focuses on installing Visual Studio Code on macOS. It provides instructions on downloading the Visual Studio Code binary and installing it. The chapter also explains how to install the C/C++ extension for Visual Studio Code on macOS.

Connecting Visual Studio Code to Compilers on macOS

This chapter demonstrates how to connect Visual Studio Code to the previously installed compilers on macOS. It explains how to configure Visual Studio Code to use GCC, Clang, and Clang LLVM compilers for building C++ projects.

Online Compilers

This chapter explores the use of online compilers for C++ development. It introduces popular online compilers like OneCompiler, Compiler Explorer, and Coliru, highlighting their features and benefits. The chapter demonstrates how to use these online compilers to test C++ code and share it with others.

First C++20 Program

This chapter guides viewers through writing their first C++20 program. It explains the basic structure of a C++ program, including the #include directive, the main function, and the use of std::cout and std::endl for printing output to the console. The chapter also introduces the spaceship operator (<=>) and demonstrates its use in a simple C++20 program.

Comments in C++

This chapter focuses on comments in C++. It explains the purpose of comments, which are used to add human-readable explanations to C++ code. The chapter covers two types of comments: single-line comments (//) and block comments (/* */). It also emphasizes the importance of using comments judiciously and avoiding excessive commenting.

Errors and Warnings in C++

This chapter discusses errors and warnings in C++ programs. It explains the different types of errors, including compile-time errors, runtime errors, and warnings. The chapter provides examples of each type of error and demonstrates how to identify and fix them.

Statements and Functions in C++

This chapter delves into statements and functions in C++. It explains that statements are the basic units of computation in C++ and must end with a semicolon. The chapter also introduces the concept of functions, which are reusable blocks of code that can take input, perform operations, and return output. It provides examples of different types of functions and demonstrates how to declare, define, and call them.

Input and Output in C++

This chapter focuses on input and output operations in C++. It explains the use of std::cin and std::cout for reading data from the console and writing data to the console, respectively. The chapter also covers the use of std::cerr for printing error messages and std::clog for printing log messages. It demonstrates how to read data with spaces using std::getline and explains the concept of chaining input stream operators.

C++ Execution Model

This chapter explores the C++ execution model, providing a simplified overview of how C++ programs are loaded into memory and executed by the CPU. It explains the concepts of virtual memory, the memory management unit (MMU), and the different sections of the memory map, including the text section, data section, heap, and stack. The chapter also discusses the role of the CPU in executing instructions statement by statement.

C++ Core Language, Standard Library, and STL

This chapter clarifies the differences between the C++ core language, the standard library, and the Standard Template Library (STL). It explains that the core language provides the fundamental building blocks of C++, while the standard library offers a collection of ready-to-use components. The STL is a specialized part of the standard library that provides container types, algorithms, and iterators.

Variables and Data Types in C++

This chapter delves into variables and data types in C++. It explains that variables are named pieces of memory used to store data. The chapter covers various fundamental data types, including int, double, float, char, bool, void, and auto. It also discusses the concept of bits and bytes and how they are used to represent data in memory.

Number Systems in C++

This chapter explores number systems in C++, explaining how they are used to transform data between human-readable formats and computer-readable formats (ones and zeros). It covers the decimal system (base 10), the binary system (base 2), the octal system (base 8), and the hexadecimal system (base 16). The chapter demonstrates how to represent numbers in different number systems using C++ syntax.

Integers in C++

This chapter focuses on integers in C++. It explains that integers are represented by the int data type and are used to store whole numbers. The chapter covers different ways to initialize integer variables, including braced initialization, functional initialization, and assignment initialization. It also discusses the concept of integer modifiers, such as signed, unsigned, short, and long, which affect the size and range of values that can be stored in integer variables.

Fractional Numbers in C++

This chapter explores fractional numbers, also known as floating-point numbers, in C++. It explains that floating-point numbers are used to represent numbers with fractional parts and are represented by the float, double, and long double data types. The chapter discusses the concept of precision, which refers to the number of digits that can be accurately represented by a floating-point type. It also covers narrowing conversions, scientific notation, and special values like infinity and NaN.

Booleans in C++

This chapter focuses on booleans in C++. It explains that booleans are used to store two states: true and false. The chapter discusses the use of booleans in conditional statements and how they are represented in memory. It also covers the std::boolalpha manipulator, which forces std::cout to print boolean values as true and false instead of 1 and 0.

Characters and Text in C++

This chapter explores characters and text in C++. It explains the use of the char data type to represent individual characters and how characters are stored in memory using the ASCII encoding. The chapter demonstrates how to declare, initialize, and print character arrays. It also emphasizes the importance of null-terminated strings (C-strings) for proper output using std::cout.

The auto Keyword in C++

This chapter introduces the auto keyword in C++. It explains that auto allows the compiler to deduce the data type of a variable based on its initializer. The chapter demonstrates how auto can be used to simplify code and avoid explicitly typing long type names.

Assignments in C++

This chapter focuses on assignments in C++. It explains that after a variable is initialized, it can be assigned a new value using the assignment operator (=). The chapter demonstrates how assignments work with different data types, including integers, doubles, booleans, and characters. It also highlights the importance of being careful when using auto type deduction in assignments to avoid potential problems.

C++ Development Workflow

This chapter provides a comprehensive overview of the C++ development workflow, covering the steps involved in compiling and running a C++ program. It explains the roles of the preprocessor, compiler, and linker in transforming source code into an executable binary file. The chapter also discusses the concept of translation units and how they are used to manage code across multiple files.

Basic Operations in C++

This chapter covers basic arithmetic operations in C++, including addition, subtraction, multiplication, division, and the modulus operator. It explains how these operators work with integers and provides examples of their usage. The chapter also discusses the concept of operator precedence and associativity, which determine the order in which operations are performed in an expression.

Prefix and Postfix Operators in C++

This chapter explores prefix and postfix increment and decrement operators in C++. It explains the difference between prefix and postfix operators, highlighting how they affect the timing of the increment/decrement operation. The chapter provides examples of both prefix and postfix operators and demonstrates their usage in simple C++ programs.

Compound Assignment Operators in C++

This chapter introduces compound assignment operators in C++. It explains that compound assignment operators combine an arithmetic operation with an assignment in a single step. The chapter covers compound assignment operators for addition, subtraction, multiplication, division, and modulus. It demonstrates how these operators can simplify code and make it more concise.

Relational Operators in C++

This chapter focuses on relational operators in C++. It explains that relational operators are used to compare values and return a boolean result (true or false). The chapter covers the following relational operators: ==, !=, <, >, <=, and >=. It demonstrates how to use these operators in conditional statements and how they are evaluated in expressions.

Logical Operators in C++

This chapter explores logical operators in C++. It explains that logical operators work on boolean operands and combine them to produce a boolean result. The chapter covers the following logical operators: && (AND), || (OR), and ! (NOT). It provides examples of how to use these operators in conditional statements and how they are evaluated in expressions.

Output Formatting in C++

This chapter focuses on output formatting in C++. It explains how to use manipulators from the iostream and iomanip libraries to control the appearance of output printed to the console using std::cout. The chapter covers manipulators like std::endl, std::flush, std::setw, std::left, std::right, std::internal, std::setfill, std::boolalpha, std::showpos, std::dec, std::hex, std::oct, std::scientific, and std::fixed. It demonstrates how to use these manipulators to format output, control justification, set precision, and display numbers in different bases.

Numeric Limits in C++

This chapter introduces the limits library in C++. It explains how to use functions from this library to determine the minimum, maximum, and lowest values representable by different numeric types. The chapter provides examples of using functions like std::numeric_limits<T>::min(), std::numeric_limits<T>::max(), and std::numeric_limits<T>::lowest().

Math Functions in C++

This chapter explores math functions available in the cmath library in C++. It covers functions like std::floor(), std::ceil(), std::abs(), std::exp(), std::pow(), std::log(), std::log10(), std::sqrt(), and std::round(). The chapter provides examples of how to use these functions to perform various mathematical operations.

Weird Integral Types in C++

This chapter discusses integral types smaller than 4 bytes in size, such as char and short int. It explains that these types do not support arithmetic operations directly and that the compiler will implicitly convert them to int when performing such operations. The chapter emphasizes the importance of being aware of this implicit conversion behavior, as it can affect the size and behavior of variables in C++ programs.

Arrays in C++

This chapter introduces arrays in C++. It explains that arrays are used to store collections of elements of the same data type. The chapter covers how to declare, initialize, and access elements in arrays using indexing. It also discusses the concept of array bounds and the dangers of accessing data outside the bounds of an array. The chapter demonstrates how to write data to arrays, initialize arrays with data, and perform operations on array elements.

Size of an Array in C++

This chapter focuses on determining the size of an array at runtime. It introduces the std::size function, which was introduced in C++17, and explains how to use it to get the number of elements in an array. The chapter also discusses the use of the sizeof operator for getting the size of an array, but emphasizes that it includes the null terminator. It also highlights the benefits of using range-based for loops for iterating through arrays.

Arrays of Characters in C++

This chapter explores arrays of characters in C++. It explains that arrays of characters can be used to represent strings and that they are often referred to as C-strings. The chapter discusses the importance of null-terminated strings for proper output using std::cout and demonstrates how to declare, initialize, and print character arrays. It also introduces string literals, which provide a more convenient way to initialize character arrays with string data.

Array Bounds in C++

This chapter focuses on the concept of array bounds in C++. It explains that arrays have a fixed size and that accessing data outside the bounds of an array can lead to undefined behavior, including program crashes or memory corruption. The chapter provides examples of accessing data outside array bounds and emphasizes the importance of staying within the legal boundaries of an array.

Pointers in C++

This chapter introduces pointers in C++. It explains that pointers are special variables that store memory addresses of other variables. The chapter covers how to declare, initialize, and use pointers to access and modify data stored at the addresses they point to. It also discusses the concept of null pointers and the importance of initializing pointers before using them.

Pointer to Character Types in C++

This chapter focuses on pointers to character types in C++. It explains how to declare, initialize, and use pointers to characters. The chapter demonstrates how pointers to characters can be used to work with C-strings and how they can be initialized with string literals. It also highlights the importance of using const pointers to prevent accidental modification of string data.

C++ Program Memory Map

This chapter revisits the C++ program memory map, providing a more detailed explanation of how programs are loaded into memory and executed. It introduces the concepts of virtual memory, the memory management unit (MMU), and the different sections of the memory map, including the text section, data section, heap, and stack. The chapter also discusses the role of the MMU in transforming between the virtual memory map and the real memory layout in RAM.

Dynamic Memory Allocation in C++

This chapter explores dynamic memory allocation in C++. It explains how to use the new operator to allocate memory on the heap and how to release memory using the delete operator. The chapter emphasizes the importance of initializing pointers before using them and the dangers of using uninitialized or deleted pointers. It also discusses the concept of memory leaks and how to avoid them.

Dangling Pointers in C++

This chapter focuses on dangling pointers in C++. It explains that dangling pointers are pointers that point to invalid memory locations. The chapter covers three common causes of dangling pointers: uninitialized pointers, deleted pointers, and multiple pointers pointing to the same memory location. It also discusses solutions for avoiding dangling pointers, including initializing pointers with null pointers, resetting pointers to null pointers after deleting memory, and using a master pointer to control memory release.

When new Fails in C++

This chapter explores the possibility of the new operator failing to allocate memory on the heap. It explains that while new failures are rare in practice, it's important to handle them to prevent program crashes. The chapter covers two methods for handling new failures: using the exception mechanism with try and catch blocks and using the std::nothrow option with the new operator.

Null Pointer Safety in C++

This chapter focuses on null pointer safety in C++. It explains that null pointer safety involves taking measures to ensure that pointers are only used when they contain valid memory addresses. The chapter covers techniques for checking pointers against null pointers and emphasizes the importance of resetting pointers to null pointers after deleting memory. It also clarifies that it's safe to call delete on a null pointer.

Memory Leaks in C++

This chapter discusses memory leaks in C++. It explains that memory leaks occur when dynamically allocated memory is no longer accessible by the program, leading to wasted memory resources. The chapter covers common causes of memory leaks, including losing pointers to dynamically allocated memory, double allocation, and allocating memory within nested scopes. It emphasizes the importance of avoiding memory leaks and releasing memory using the delete operator when it's no longer needed.

Dynamically Allocated Arrays in C++

This chapter explores dynamically allocated arrays in C++. It explains how to use the new operator to allocate arrays on the heap and how to release memory using the delete[] operator. The chapter highlights the differences between dynamically allocated arrays and static arrays, emphasizing that dynamically allocated arrays do not work with std::size or range-based for loops.

References in C++

This chapter introduces references in C++. It explains that references are aliases for variables, allowing you to use a different name to refer to the same variable. The chapter covers how to declare, initialize, and use references to access and modify data. It also discusses the concept of const references, which prevent modification of the referenced variable.

Comparing Pointers and References in C++

This chapter compares pointers and references in C++. It highlights the key differences between them, including the use of the dereference operator (*) with pointers, the inability to reassign references, and the requirement to initialize references at declaration. The chapter also discusses the analogy of const references to const pointers.

The const Keyword with References in C++

This chapter explores the use of the const keyword with references in C++. It explains that const references create aliases that cannot be used to modify the referenced variable. The chapter demonstrates how to declare const references and how they differ from non-const references. It also discusses the use of const pointers to simulate the behavior of const references.

Manipulating Text Data in C++

This chapter introduces the concept of manipulating text data in C++. It explains that character arrays can be used to model C-strings, which are null-terminated strings. The chapter covers various facilities from the cstring library for manipulating C-strings, including strlen, strcmp, strcat, and strcpy. It also discusses the limitations of C-strings, such as the need to manage array bounds and null terminators.

Manipulating Characters in C++

This chapter focuses on manipulating individual characters in C++. It introduces various facilities from the cctype library for working with characters, including isalnum, isalpha, isspace, islower, isupper, isdigit, tolower, and toupper. The chapter demonstrates how to use these facilities to check character properties, convert characters between cases, and perform other character-related operations.

C-String Manipulation in C++

This chapter explores the cstring library in C++, which provides functions for manipulating C-strings. It covers functions like strcat, strcpy, and strlen, demonstrating how to concatenate, copy, and determine the length of C-strings. The chapter also discusses the potential safety issues associated with these functions, such as the need to ensure that destination arrays are large enough to accommodate the concatenated or copied data.

The std::string Type in C++

This chapter introduces the std::string type in C++. It explains that std::string is a high-level type that provides a more convenient and safer way to work with string data compared to character arrays. The chapter covers how to declare, initialize, and use std::string objects, highlighting its automatic memory management and support for various string operations.

Declaring and Using std::string in C++

This chapter provides a detailed explanation of how to declare, initialize, and use std::string objects in C++. It covers various initialization methods, including initializing with string literals, other strings, and multiple copies of a single character. The chapter also demonstrates how to print std::string objects using std::cout and how std::string objects can automatically grow to accommodate additional characters.

The One Definition Rule in C++

This chapter explains the One Definition Rule (ODR) in C++. It states that definitions of variables, functions, and static members cannot appear more than once in a program. The chapter discusses exceptions to the ODR, particularly for classes, where definitions can appear in multiple translation units. It provides examples of violating the ODR and demonstrates how to avoid compiler errors related to multiple definitions.

Functions in C++

This chapter introduces functions in C++. It explains that functions are reusable blocks of code that can take input, perform operations, and return output. The chapter covers the syntax for declaring and defining functions, including specifying the return type, function name, parameters, and function body. It also discusses the concept of function signatures, which uniquely identify functions based on their name and parameters. The chapter demonstrates how to call functions and pass arguments to them.

Function Declarations and Definitions in C++

This chapter focuses on function declarations and definitions in C++. It explains that functions can be split into two parts: a declaration (prototype) and a definition. The declaration provides a summary of the function's return type, name, and parameters, while the definition includes the function body with the actual implementation. The chapter demonstrates how to separate function declarations and definitions and emphasizes the importance of placing declarations before function calls.

Passing Parameters to Functions by Value in C++

This chapter explains the concept of passing parameters to functions by value. It demonstrates that when parameters are passed by value, copies of the arguments are created and used within the function body. The chapter highlights that modifications made to parameters passed by value do not affect the original arguments.

Passing Parameters to Functions by Pointer in C++

This chapter explores passing parameters to functions by pointer. It explains that passing by pointer allows you to modify the original arguments by dereferencing the pointer within the function body. The chapter demonstrates how to declare functions that take pointers as parameters and how to pass the addresses of variables as arguments.

Passing Parameters to Functions by Reference in C++

This chapter introduces passing parameters to functions by reference. It explains that passing by reference creates aliases for the original arguments, allowing you to modify them directly within the function body. The chapter demonstrates how to declare functions that take references as parameters and how to pass variables as arguments. It highlights the benefits of passing by reference, such as avoiding copies and simplifying code.

Returning from Functions in C++

This chapter focuses on returning data from functions in C++. It explains that functions can return values using the return keyword. The chapter demonstrates how to return values from functions and how the returned values are used in the calling context. It also discusses the concept of return by value and how the compiler may optimize returns by value to return by reference in certain cases.

Function Overloading in C++

This chapter introduces function overloading in C++. It explains that function overloading allows you to define multiple functions with the same name but different parameters. The chapter covers the rules for creating valid function overloads, emphasizing that the return type is not considered when determining function uniqueness. It demonstrates how the compiler selects the appropriate overload based on the arguments passed during function calls.

Overloading Functions with Different Parameters in C++

This chapter provides a detailed explanation of how to overload functions based on different parameters. It covers techniques for creating overloads by changing the types of parameters, the order of parameters, and the number of parameters. The chapter demonstrates how the compiler resolves function calls based on the types and order of arguments passed.

Lambda Functions in C++

This chapter introduces lambda functions in C++. It explains that lambda functions are anonymous functions, meaning they don't have a name. The chapter covers the syntax for declaring and defining lambda functions, including the capture list, parameter list, return type, and function body. It demonstrates how to give lambda functions names and how to call them directly or through handles.

Declaring and Using Lambda Functions in C++

This chapter provides a detailed explanation of how to declare and use lambda functions in C++. It covers the syntax for defining lambda functions, including the capture list, parameter list, return type, and function body. The chapter demonstrates how to give lambda functions names and how to call them directly or through handles. It also explains how to pass parameters to lambda functions and how to return values from them.