The 2023 Premium C Programming Developer Bundle

Your First Program

Start Here

• Introduction - 3:01
• Visual Studio 2015 Installation - 4:32
• Visual Studio 2017 Installation - 2:44
• Blocks Installation - 5:06
• Cevelop Installation - 5:22
• XCode Installation on MacOS - 3:28

Basic Language Facilities

• What is C++? - 3:31
• First C++ Program - 9:12
• The C++ Compilation Process - 3:09
• Primitive Types and Variables - 7:57
• Basic Input/Output - 5:56
• Functions Basics - Part I - 7:28
• Functions Basics - Part II - 9:05
• Overview of Debugging in Visual Studio - 5:40
• Uniform Initialization (C++11) - 9:21
• Pointers - 8:25
• Reference - 5:32
• Reference Versus Pointer - 6:58
• The const Qualifier - 4:19
• const Qualifier and Compound Types - 7:30
• Automatic Type Inference (C++11) - 7:00
• Range-Based For Loop - I (C++11) - 4:32
• Range-Based For Loop - II (C++11) - 6:12
• Function Overloading - 13:27
• Default Function Arguments - 3:43
• Inline Functions - 7:36
• Function Pointers - 4:53
• Namespace - 9:24

Memory Management – Part I

• Dynamic Memory Allocation - Part I (malloc Function) - 9:36
• Dynamic Memory Allocation - Part II (new Operator) - 6:19
• Dynamic Memory Allocation - Part III (new[] Operator) - 6:40
• Dynamic Memory Allocation - Part IV (2D Arrays) - 5:07

Classes and Objects

• Object-Oriented Programming Basics - 5:50
• Class - 5:31
• Constructor and Destructor - 4:28
• Structures - 2:38
• Non-Static Data Member Initializers (C++11) - 4:39
• this Pointer - 4:46
• Constant Member Functions - 3:14
• Static Class Members - 5:12
• Copy Constructor - Part I - 4:52
• Copy Constructor - Part II - 4:40
• Delegating Constructors (C++11) - 4:01
• Default and Deleted Functions (C++11) - 5:18
• L-values, R-values, and R-value References (C++11) - 7:10
• Move Semantics - Basics (C++11) - 3:23
• Move Semantics - Implementation (C++11) - 4:19
• Copy Elision - 8:26
• Move Semantics - std::move Function (C++11) - 2:55

Move Semantics

• Value Categories - 7:10
• Move Semantics – Basics - 3:23
• Move Semantics – Implementation - 3:45
• Rule of 5 and 0 - 14:30
• Copy Elision - 8:22
• std::move Function - 7:52

Operator Overloading

• Operator Overloading - Part I (Basics) - 8:29
• Operator Overloading - Part II (Assignment Operator) - 4:18
• Operator Overloading - Part III (Global Overloads) - 5:48
• Operator Overloading - Part IV (Friend Keyword) - 2:29
• Operator Overloading - Part V (Smart Pointer Basics) - 5:04
• Operator Overloading - Part VI (Smart Pointers in C++11) - 4:34
• Operator Overloading - Part VII (Rules) - 1:55
• Type Conversions - Part I (Basics) - 5:56
• Type Conversions - Part II (Primitive to User Type) - 5:40
• Type Conversions - Part III (User to Primitive Type) - 2:50
• Initialization Versus Assignment and Member Initialization List - 5:18

Memory Management – Part II

• Raw Pointers - 5:12
• std::unique_ptr - 10:13
• Sharing Pointers - 6:12
• Sharing std::unique_ptr - 4:35
• std::shared_ptr - 5:21
• Weak Ownership - 8:50
• std::weak_ptr Internals - 6:28
• Circular References - 10:28
• Deleter - 7:07
• Dynamic Arrays - 3:27
• Make Functions - 5:43

More C++ Goodies

• Enums - Part I (Basics) - 3:42
• Enums - Part II (Scoped Enums C++11) - 5:32
• Strings - Part I (Raw Strings) - 6:49
• Strings - Part II (std::string) - 10:05
• Strings - Part III (String Streams) - 9:45
• Constant Expressions - constexpr (C++11) - 9:24
• std::initializer_list (C++11) - 8:27
• Dynamic Array (std::vector) - 8:43
• Union - I - 4:51
• Union - II - 4:56

Object-Oriented Programming

• Inheritance and Composition - 6:01
• Inheritance and Access Modifiers - 3:55
• Project - Part I (Beginning) - 2:06
• Project - Part II (Account and Savings Implementation) - 6:59
• Project - Part III (Inheriting Constructors) - 6:31
• Project - Part IV (Virtual Keyword) - 8:53
• Project - Part V (Virtual Mechanism Internals) - 7:11
• Project - Part VI (Virtual Mechanism Walk-through and Virtual Destructor) - 6:43
• Project - Part VII (override and final specifier) - 6:13
• Project - Part VIII (Upcasting and Downcasting) - 5:45
• Project - Part IX (RTTI Basics) - 7:11
• Project – Part X (dynamic_cast) - 6:08
• Abstract Class - 6:03
• Multiple (Diamond) Inheritance - 9:22

Exception Handling

• Exception Handling - Part I (Basics) - 7:59
• Exception Handling - Part II (Multiple Catch Blocks) - 3:59
• Exception Handling - Part III (Stack Unwinding) - 6:31
• Exception Handling - Part IV (Nested Exceptions) - 5:11
• Exception Handling - Part V (Constructor and Destructor) - 7:06
• Exception Handling - Part VI - (noexcept Keyword in C++11) - 8:20

File Input and Output

• Raw String Literals (C++11) - 4:03
• Introduction to Filesystem Library (C++17) - 3:49
• File IO - Part I (Basics) - 6:44
• File IO - Part II (Error Handling) - 5:43
• File IO - Part III (Copy Utility) - 3:29
• File IO - Part IV (Character IO and Seeking) - 7:22
• File IO - Part V (Binary IO) - 8:30

Templates

• Introduction to Templates - 7:48
• Template Argument Deduction and Instantiation - 6:28
• Explicit Specialization - 5:54
• Non-type Template Arguments - 7:15
• Perfect Forwarding - Part I (C++11) - 7:23
• Perfect Forwarding - Part II (C++11) - 5:32
• Variadic Templates - Part I (C++11) - 9:47
• Variadic Templates - Part II (C++11) - 4:50
• Class Templates - 8:34
• Class Template Explicit Specialization - Part I - 5:41
• Class Template Explicit Specialization - Part II - 4:02
• Class Template Partial Specialization - 6:52
• Typedef, Type Alias, and Alias Templates (C++11) - 8:00
• Type Traits (C++11) - 7:21
• static_assert (C++11) - 4:19

Lambda Expressions (C++11)

• Callbacks Revisited - Function Pointers - 6:39
• Callbacks - Function Objects - 6:57
• Lambda Expressions - 4:36
• Lambda Expressions - Internals - 5:01
• Lambda Expressions Capture List - Part I - 8:25
• Lambda Expressions Capture List - Part II - 4:08
• Lambda Expressions Capture List - Part III - 5:52
• Generalized Lambda Capture - 4:33

Standard Template Library

• Introduction - 2:50
• std::array (C++11) - 4:02
• std::vector - 4:38
• std::deque - 2:21
• std::list and std::forward_list (C++11) - 4:59
• std::set and std::multiset - 5:42
• std::map and std::multimap - 7:35
• Unordered Containers (C++11) - 8:01
• std::hash (C++11) - 2:42
• Big O Notation and Performance of Containers - 5:04
• Algorithms - Part I - 8:15
• Algorithms - Part II - 7:04

C++ Concurrency

• Concurrency Basics - 6:12
• Thread Creation (std::thread) - 5:47
• Passing Arguments to Threads - 4:18
• Thread Synchronization (std::mutex) - 6:18
• std::lock_guard - 2:45
• std::thread Functions and std::this_thread Namespace - 7:48
• Task-Based Concurrency - Part I - 5:07
• Task-Based Concurrency - Part II - 3:44
• Launch Policies - 4:38
• std::future Wait Functions - 5:07
• Using std::promise - 5:36
• Propagating Exceptions Across Threads - 3:15

C++17 Core Language Features

• Deprecated and Removed Features - 3:53
• Changes - 3:12
• Attributes - 5:58
• Feature Test Macros - 5:51
• If and switch with Initialization - 5:47
• Inline Variables - 5:45
• Nested Namespaces - 1:51
• noexcept - 3:35
• constexpr Lambda - 7:47
• Structured Bindings - 8:07
• Expression Evaluation Order - 6:36
• Mandatory Copy Elision - I - 4:28
• Mandatory Copy Elision - II - 4:33

C++17 Template Features

• Compiled Time Argument Deduction (CTAD) - 5:41
• Folding Basics - 4:05
• Fold Expressions - Unary Folds - 4:27
• Fold Expressions - Binary Folds - 5:48
• Fold Expressions - Recap - 2:34
• Type Traits Suffixes - 3:22
• if constexpr - I - 7:42
• if constexpr - II - 4:43

C++17 Standard Library Components

• std::optional - I - 5:18
• std::optional - II - 3:50
• std::optional - III - 3:38
• std::variant - I - 5:57
• std::variant - II - 4:34
• std::variant - III - 5:58
• std::any - 6:33
• std::string_view - I - 8:39
• std::string_view - II - 8:13
• Filesystem - path - 5:49
• Filesystem - directory_entry - 7:00
• Filesystem - Directory Functions - 5:09
• Filesystem - Permissions - 5:44
• Parallel Algorithms - I - 3:49
• Parallel Algorithms - II - 7:32
• Parallel Algorithms - III - 4:24

• Overview - 0:50
• Downloading Keil Vision - 1:18
• Installing Keil μVision - 6:23
• Installing Packs - 4:19
• Overview of Keil μVision - 10:02

• Developing a UART Driver for Monitoring Results - 41:58
• Creating an LED Class in Object-Oriented C (Part I) - 29:54
• Creating an LED Class in Object-Oriented C (Part II) - 29:58
• Creating an LED Class in C++ - 26:44

• Inheriting a Class in Object-Oriented C (Part 1) - 15:13
• Inheriting a Class in Object-Oriented C (Part 2) - 5:43
• Inheriting a Class in Object-Oriented C (Part 3) - 6:25
• Implementing Inheritance in C++ - 16:55

• Implementing a Structure to Hold Registers - 36:53
• Implementing the RCC Registers Structure - 24:26
• Testing the Driver - 11:56
• Adding all GPIO Ports to the Driver - 12:34
• Creating the Interface and Implementation Files - 3:23
• Implementing the Library - 28:22
• Implementing the Library Functions - 20:43
• Testing the Library - 4:49

• Another Class to Our Firmware in C - 15:03
• Implementing Polymorphism in C (Part I) - 29:51
• Implementing Polymorphism in C (Part II) - 23:56

• Extending the GPIO Library for Handling Alternate Functions - 32:40

• Developing a General-Purpose Input / Output Library in C++ - 48:01

• Implementing the UART Registers Structure - 21:06
• Developing the UART Driver - 23:27
• Developing the UART Library (PART I) - 37:58
• Developing the UART Library (PART II) - 5:15
• Testing the UART Library - 2:49

• Developing the UART Library in C++ - 18:37

• Implementing the SysTick Registers Structure - 15:03
• Testing the SysTick Library C - 8:48
• Writing the SysTick Library C - 14:22
• Implementing the SysTick Library C++ - 15:58

• Download CubeIDE - 4:13
• Setting Up STM32CubeIDE - 7:25
• Installing Packages - 6:07
• Overview - 17:17
• Writing a GPIO Driver from Scratch (Part I) - 34:02
• Writing a GPIO Driver from Scratch (Part II) - 17:29

• Closing Remarks - 0:11

• Introduction to Patterns - 4:57
• Overview of UML Class Diagram - 8:24
• S.O.L.I.D. Principles - I - 4:56
• S.O.L.I.D. Principles - II - 4:59
• S.O.L.I.D. Principles - III - 5:14
• Overview of Creational Patterns - 2:11
• Slide Deck

• Source code
• Introduction - 3:49
• Basic Example - 3:16
• Logger Class - I - 7:22
• Logger Class - II - 5:48
• Lazy Instantiation - 4:08
• Destruction Policies - 8:12
• Multithreading Issues - 6:11
• Why DCLP Fails - 8:08
• Meyers Singleton - 2:46
• Using std::call_once - 4:38
• CRTP Idiom - 4:39
• Clock Class - 5:27
• Monostate - 5:58
• Singleton vs Monostate - 2:33
• Singleton Issues - 5:44
• Registry Of Singletons - I - 9:37
• Registry Of Singletons - II - 8:23
• Pros & Cons - 4:22

• Source Code
• Introduction - 6:16
• Basic Example - I - 4:52
• Basic Example - II - 7:21
• Application Framework Overview - 3:22
• Application Framework Implementation - 3:52
• Application Framework with Factory Method - 8:04
• Parameterized Factory Method - 9:07
• std::unique_ptr - 6:41
• std::shared_ptr - 7:23
• Pros & Cons - 5:03

• Source Code
• Introduction - 5:06
• Basic Example - 6:29
• Pooling Game Objects - I - 7:23
• Pooling Game Objects - II - 6:02
• Multiple Actors - I - 4:19
• Multiple Actors - II - 7:37
• Multiple Actors - III - 9:12
• Generic Pool - I - 5:45
• Generic Pool - II - 9:10
• Pros & Cons - 3:43

• Source Code
• Introduction - 6:16
• Basic Example - I - 6:24
• Basic Example - II - 6:40
• Database Framework Introduction - 5:40
• Database Framework Implementation - 3:47
• SqlServer Database Classes - 6:29
• MySql Database Classes - 3:13
• Database Framework Usage - 4:29
• Using Factory Method - 8:24
• Using Abstract Factory - 6:26
• Pros & Cons - 8:14

• Source Code
• Introduction - 3:58
• Cloning Types - 4:39
• Basic Example - 4:49
• Game Introduction - 3:29
• Game Implementation - I - 6:54
• Game Implementation - II - 4:36
• Game Implementation - III - 7:22
• Cloning Example - 4:52
• Prototype Implementation - I - 6:46
• Prototype Implementation - II - 3:22
• Prototype Implementation - III - 5:35
• Class Vs Object - 4:55
• Varying State - 4:38
• Prototype Manager - I - 6:09
• Prototype Manager - II - 4:10
• Prototype Manager - III - 3:30
• Pros & Cons - 6:07

• Source Code
• Introduction - 4:27
• Basic Example - 5:40
• File Example Introduction - 5:43
• Memory Management - 5:46
• Issues - 6:01
• Builder Implementation - 4:06
• Modern Implementation - 6:57
• Fluent Builder - 5:41
• Pros & Cons - 4:13

• Section Overview - 2:14
• Getting Started on Windows with Visual Studio Integrated Development Environment (IDE) - 10:05
• Getting Started on macOS or Linux with CodeBlocks IDE - 10:57
• Getting Started with macOS Catalina or Higher with Visual Studio Code - 14:48
• Finding Answers to Your Questions - 2:32

• Section Overview - 2:15
• Saying Hello to C++ - 11:21
• Variables and Data Types - Part 1 - 10:32
• Variables and Data Types - Part 2 - 9:12
• Variables and Data Types - Part 3 - 7:25
• Comments - 6:57
• Arithmetic Operators - 19:28
• Relational Operators - 8:44
• Logical Operators - 12:34
• Symbolic Constants and Naming Conventions - 9:47
• User Input - 15:19
• Project - Average of Three - 6:46
• Project - MadLibs Clone - 14:11
• Section Wrap-Up - 2:24

• Section Overview - 1:28
• Introduction to Control Statements - 7:36
• Selection Control Statements - 21:30
• Repetition Control Statements - 17:56
• The Break and Continue Statements - 9:38
• Random Numbers - 11:08
• Project - Jam of the Month Club - 12:32
• Project - Odds and Evens - 5:03
• Project - Guess the Number - 10:42
• Section Wrap-Up - 2:01

• Section Overview - 1:26
• Built-In Arrays - 18:31
• The Array Class - 13:20
• The Vector Class - 15:09
• Multi-Dimensional Arrays - 11:15
• Project - Array Data - 6:20
• Project - Vector Data - 6:46
• Project - Parallel Arrays/Vectors - 9:57
• Section Wrap-Up - 1:48

• Section Overview - 0:56
• Function Prototypes and Definitions - 8:19
• Function Return Types and Parameters - 16:57
• Parameter Passing: Pass-By-Value and Pass-By-Reference - 14:53
• Variable Scope and Lifetime - 17:32
• Function Overloading - 7:55
• The Library - 9:26
• Recursion - 17:27
• Project - Return the Product of Three Parameters - 3:52
• Project - Return the Sum of Built-In Array Elements - 5:37
• Project - Return the Sum of Array Object Elements - 4:29
• Project - Retrieve the Sum of Array Object Elements by Reference - 6:57
• Project - Tic-Tac-Toe (Advanced) - 30:56
• Section Wrap-Up - 1:23

• Section Overview - 1:48
• Basics of Object-Oriented Programming (OOP) - 3:22
• Encapsulation: Data Members and Member Functions - 23:53
• Separate Compilation - 18:42
• Constructors and Destructors - 12:23
• A Rectangle Class - 16:10
• A Book Class - 19:43
• Project - A Bank Account Class - 16:46
• Project - A Pizza Class - 14:29
• Project - A Circle Class - 13:09
• Section Wrap-Up - 3:49

• Section Overview - 1:30
• Exceptions and the Exception Hierarchy - 14:59
• Logic Errors - 8:55
• Runtime Errors and Throwing Exceptions - 20:09
• Rethrowing Exceptions - 16:26
• Custom Exceptions - 14:46
• Basic Testing and Debugging - 17:08
• Project - Throwing and Handling an outofrange Exception - 7:06
• Project - Creating and Using Your Own Exception - 8:32
• Section Wrap-Up - 2:01

• Section Overview - 2:02
• Introduction to Pointers - 14:12
• Dynamic Memory - Part 1 - 10:27
• Dynamic Memory - Part 2 - 17:40
• Const Correctness - 18:19
• Project - Dynamically Creating Rectangles - 9:43
• Project - Dynamically Creating Circles - 11:09
• Section Wrap-Up - 1:25

• Section Overview - 1:37
• Sequential File Output - 14:51
• Sequential File Input - 8:19
• More File Input/Output (I/O) - 11:27
• Project - Reading Data from File and Printing Statistics - 8:58
• Project - Dynamically Creating Rectangles from File - 12:46
• Project - Shopping Item File - 15:07
• Section Wrap-Up - 1:31

• Section Overview - 2:14
• Inheritance - Part 1 - 11:58
• Inheritance - Part 2 - 11:14
• Polymorphism and Late Binding - 14:04
• Enumerated Types - 7:13
• Project - Derived Cat Class - 10:57
• Project – Role Playing Game (RPG) Player Character Creation - 48:28
• Section Wrap-Up - 2:27

• Section Overview - 1:43
• Templates - Standard Template Library (STL) - 22:59
• Standard Template Library (STL) - Part 1
• Standard Template Library (STL) - Part 2 - 15:40
• Smart Pointers - 14:16
• Friend Functions and Friend Classes - 14:07
• Operator Overloading - 13:44
• Project - Dictionary of Terms - 19:48
• Project - Aliens - 19:13
• Section Wrap-Up - 1:29

• Modern C++ Programming Cookbook - Second Edition

• C++ High Performance - Second Edition

• Expert C++

• Modern CMake for C++