Beg Modern Cpp

What is C++? Preview 03:31

Introduces Modern C++ and where it is used. It explains why C++ is chosen over other languages.

First C++ Program Preview 09:12

This video explains the structure of the first C++ program. It also gives an overview of compilation in Visual Studio.

The C++ Compilation Process Preview 03:09

Explains the C++ build process in detail.

Primitive Types & Variables Preview 07:57

Introduces primitive types in C++.

Basic Input/Output Preview 05:56

Gives overview of basic input/output classes and demonstrates how to write on the console & read from the keyboard.

Functions Basics - Part I Preview 09:13

This lecture explains the basics of functions in C++.

Functions Basics - Part II Preview 09:05

I'll discuss the concept of function declaration & definition. And we'll see some more examples of functions.

Overview of Debugging in Visual Studio Preview 05:40

Gives a gentle introduction to debugging  C++ applications in Visual Studio and also explains a few common shortcuts.

Uniform Initialization (C++11) Preview 09:21

Learn about different types of initialization in C++ including the new Uniform Initialization syntax and its advantages

Pointers Preview 08:25

Introduces pointers, syntax and their usage.

Assignment Preview 00:17

Tests your understanding of pointers and their syntax.

Reference Preview 05:32

Explains reference type and how to use it instead of pointers.

Assignment Preview 00:12

Test your understanding of references.

Reference Vs Pointer Preview 06:58

Compares pointers and references and explains how to choose between them

The const Qualifier Preview 04:19

Explains the importance of const qualifier and its usage.

const Qualifer & Compound Types Preview 07:30

Explains how to use const qualifier with pointers and references.

Assignment Preview 00:23

Test your understanding of using const qualifier with pointers and references

Automatic Type Inference (C++11) Preview 07:00

Introduces the auto keyword and explains how to use it to infer types automatically.

Basics Quiz - I

This will help you gauge your understanding of the topics learned so far.

Range-Based For Loop - I (C++11) Preview 04:32

Introduces the new range-based for loop in C++11 and explains how to use it.

Range-Based For Loop - II (C++11) Preview 07:02

In this lecture, you'll understand how the range-based for loop works internally.

Function Overloading Preview 13:27

Explains function overloading and how to use it 

Default Function Arguments Preview 03:43

Another convenience feature for programmers. This video explains syntax and usage

Inline Functions Preview 07:36

Explains how to increase performance of your code by making your functions inline

Function Pointers Preview 04:53

Introduces function pointers and explains their purpose.

Namespace Preview 09:24

Explains how to use namespaces to group types together and avoid name clashes

Basics Quiz - II

This quiz will further test your knowledge of the previous topics.

Dynamic Memory Allocation - Part I (malloc function) Preview 09:36

Explains basics of dynamic memory allocation in C. This will build up a base for understanding dynamic memory allocation in C++.

Dynamic Memory Allocation - Part II (new operator) Preview 06:19

Learn how to use the new operator to allocate memory at runtime in C++. You'll also learn why new operator is preferred over malloc in C++.

Dynamic Memory Allocation - Part III (new[] operator) Preview 06:40

This lecture explains how to create arrays on heap using new [] operator. You'll also learn how to create strings on heap in C++.

Dynamic Memory Allocation - Part IV (2D arrays) Preview 05:07

Learn the basics of 2D arrays and how they're created on the heap in C++ using the new[] operator.

Dynamic Memory Allocation - Source Code Only Preview 00:02

Source code only

Object Oriented Programming Basics Preview 05:50

Gives an overview of Object Oriented programming principles and how they relate to real-life objects.

Class Preview 05:31

Explains the meaning and syntax of class

Constructor & Destructor Preview 04:28

Explains the purpose of constructors and destructor and how they can be used to manage object initialization.

Structures Preview 02:38

Explains the meaning and purpose of structures in C++

Non-static Data Member Initializers (C++11) Preview 04:39

Explains this C++11 feature and shows how to use it to initialize class members directly inside a class.

this Pointer Preview 04:46

Explains this pointer and its purpose

Constant Member Functions Preview 03:14

Explains how to create read-only functions through the const qualifier

Static Class Members Preview 05:12

Explains how to use the static keyword to create static member variables & functions

Copy Constructor - Part I Preview 04:52

Explains the copy constructor and why it is required

Copy Constructor - Part II Preview 04:40

Explains how & when to implement a user-defined copy constructor. Also explains the rule of 3.

Delegating Constructors (C++11) Preview 04:01

Explains the C++11 feature of delegating constructors and how it can be used to prevent code duplication in constructors.

Default & Deleted Functions (C++11) Preview 05:18

Explains how to use the C++11 keywords, default & delete, to control what functions are synthesized by the compiler.

Quiz I

This quiz will test your understanding of classes, constructors, destructors and copy semantics

L-values, R-values & R-value References (C++11) Preview 07:10

This lecture starts with the basics of l-values and r-values and then explains C++11 feature, R-value references.

Move Semantics - Basics (C++11) Preview 03:23

Explains the concept of move semantics and how it improves performance.

Move Semantics - Implementation (C++11) Preview 04:12

Shows how to implement move semantics in a class.

Rule of 5 & 0 Preview 14:30

Learn about the Rule of 5 & 0. Also understand in which cases the class functions are automatically synthesized by the compiler.

Copy Elision Preview 09:01

Learn about copy elision and how it eliminates extra copies of temporary objects.

std::move Function (C++11) Preview 07:52

Shows how to use std::move function to force move semantics on l-value

Quiz

This quiz will test your understanding of move semantics and the new keywords (default, delete)

Operator Overloading Demo Code Preview 00:05

Contains source code only.

Operator Overloading - Part I (Basics) Preview 08:28

Explains the basics of operator overloading and implementation of common unary & binary operators

Operator Overloading - Part II (Assignment Operator) Preview 04:18

Explains why assignment operator is important

Operator Overloading - Part III (Global Overloads) Preview 05:48

Shows when operators need to be overloaded as global functions. Also shows implementation of overloaded stream operators (<< and >>).

Operator Overloading - Part IV (Friend Keyword) Preview 02:29

Explains the purpose of friend keyword and when & where to use it.

Operator Overloading - Part V (Smart Pointer Basics) Preview 05:04

Explains the RAII idiom (Resource Acquisition Is Initialization). Shows how to overload -> and * operator to create a smart pointer.

Operator Overloading - Part VI (Smart Pointers in C++11) Preview 04:34

Demonstration of the smart pointers in C++11 (std::unique_ptr & std::shared_ptr)

Go to Section 6 for in-depth explanation of C++11 smart pointers.

Operator Overloading - Part VII (Rules) Preview 01:55

A short discussion on the operator overloading rules.

Type Conversions - Part I (Basics) Preview 05:56

Discussion on conversion between types using C++ casting operators

Type Conversions - Part II (Primitive to User Type) Preview 05:39

Explanation & implementation of how constructors are used by the compiler to perform type conversion.

Type Conversions - Part III (User to Primitive Type) Preview 02:50

Explains how to implement type conversion operator function to convert a user-defined type into primitive type.

Initialization Vs. Assignment & Member Initialization List Preview 05:18

Explains why initialization should be preferred over assignment. Also explains the concept of member initializer list.

Quiz

This will test your understanding of operator overloading & type conversions.

Raw Pointers Preview 05:11

In this lecture, I'll explain why we need smart pointers.

std::unique_ptr Preview 10:11

You'll learn about the unique_ptr and its properties in this video.

Sharing Pointers Preview 06:09

In this lesson, I'll build an example that will be used to explain why we std::unique_ptr cannot be used in all cases.

Sharing std::unique_ptr Preview 04:34

I'll try to share the pointer resource using unique_ptr and find out if it works.

std::shared_ptr Preview 05:18

Since unique_ptr cannot be used for sharing the underlying resource, I'll replace it with shared_ptr. A shared_ptr allows sharing of the underlying resource and it manages this information through a reference count. Learn how it works in this lecture.

Weak Ownership Preview 08:49

We'll look at a problem with shared_ptr while using a resource that may be destroyed anytime.

std::weak_ptr Internals Preview 06:26

Continuing from the previous lecture, you'll learn how weak_ptr can be used to weakly point to a resource without preventing it from getting destroyed. You'll also understand how it achieves this behavior.

Circular References Preview 10:27

In this lecture, we'll learn about circular references and how using shared_ptr may lead to memory leaks. Finally, we'll use weak_ptr to prevent memory leaks.

Deleter Preview 07:05

We can store any kind of resource in a smart pointer, but it needs to be released correctly. This can be done through a deleter. This lesson explains the concept and its usage.

Dynamic Arrays Preview 03:26

This lesson explains how we can use smart pointers to manage pointers to dynamic arrays.

Make Functions Preview 05:41

The construction process of a smart pointer can be simplified with std::make_ functions. You'll learn about these functions in this lesson.

Enums - Part I (Basics) Preview 03:42

Explains the purpose of enumerated types and when to use them.

Enums - Part II (Scoped Enums C++11) Preview 05:32

Implementation of scoped enums.

Strings - Part I (Raw Strings) Preview 06:49

Demonstrates raw string and their usage. You get to learn why raw strings should be avoided.

Strings - Part II (std::string) Preview 11:41

Introduces std::string class from the standard library and its usage.

Assignment I Preview 00:14

Assignment on string conversion.

Strings - Part III (String Streams) Preview 09:45

Explains string streams and their purpose. Also introduces the new string conversion functions of C++11.

Assignment II Preview 00:24

Coding assignment on std::string

User-Defined Literals Preview 05:59

Learn how to create user-defined literals for your own types.

Constant Expressions - constexpr (C++11) Preview 09:24

You'll learn how to write expressions that can be evaluated at compile time, thereby increasing the performance of your code.

std::initializer_list (C++11) Preview 08:27

This video discusses the purpose of std::initializer_list in depth.

Dynamic Array (std::vector) Preview 08:43

Introduces the std::vector class and demonstrates common operations of creation, insertion, deletion, etc.

Assignment III Preview 00:19

Union - I Preview 04:51

This lecture explains basics of unions and how to use them.

Union - II Preview 04:56

In this lecture, we'll see the caveats of using user-defined types as members in a union.

Quiz

Test your understanding on enums, strings, stringstreams & vector

Account Hierarchy Source Code Preview 00:06

Source code of Account classes

Inheritance & Composition Preview 06:01

We revisit inheritance and composition and explain it again with examples. This will give you a better understanding of these concepts.

Inheritance & Access Modifiers Preview 03:55

Explains access modifiers in context of inheritance.

Project - I (Introduction) Preview 02:06

Explains the project on inheritance, that we'll implement in the subsequent videos.

Project - II (Account & Savings Class) Preview 06:59

Implementation of the Account hierarchy

Assignment Preview 00:14

Assignment

Project - III (C++11 Inheriting Constructors) Preview 06:31

This video implements the Checking class. Shows how to invoke the base class member functions from the child classes. Also explains the inheriting constructors from C++11 and where to use them. 

Project - IV (Virtual Keyword) Preview 08:53

Introduces the virtual keyword and explains why it is needed.

Quiz I

This part will test your understanding of basic concepts of inheritance.

Project -V (Virtual Mechanism - 1) Preview 07:11

Explains the underlying implementation of virtual mechanism

Project -VI (Virtual Mechanism - 1) Preview 06:42

This video walks through the code that is generated for virtual functions in Visual Studio. It also explains why base class destructors should be virtual.

Project - Part VIII (override & final specifier in C++11) Preview 06:13

This lecture explains the purpose of override & final specifier.

Project - VIII (Object Slicing) Preview 05:45

Discussion on upcasting & downcasting within the objects of a class hierarchy. Also learn about object slicing and how to avoid it.

Project - IX (typeid Operator) Preview 07:11

This video explains the concepts of Run-time type Information and also introduces the typeid operator

Project - Part X (dynamic_cast Operator) Preview 06:08

This video explains the purpose of dynamic_cast operator & how to use it.

Abstract Class Preview 06:03

Understand the concept of pure virtual functions and the abstract classes and learn when and where to use them.

Multiple (Diamond) Inheritance Preview 09:22

This video explains the issue that arises with diamond inheritance. You'll learn how to solve it by virtual inheritance and how it is implemented internally.

Quiz II

This quiz will test your understanding of virtual mechanism, virtual inheritance & RTTI.

Exception Handling - Part I (Basics) Preview 07:59

Explains why exception handling is required and how it is better than returning simple error codes.

Exception Handling - Part II (Multiple Catch Blocks) Preview 03:58

This video explains more details on catch blocks.

1. Writing multiple catch blocks
2. Using base exception object in a catch block
3. All catch block

Exception Handling - Part III (Stack Unwinding) Preview 06:31

This video explains the concept of stack unwinding. It also explains the pitfalls of manual memory management with exception handling..

Exception Handling - Part IV (Nested Exceptions) Preview 05:11

Explains the concept of nested exception handling and demonstrates its usage with an example.

Exception Handling - Part V (Constructor & Destructor) Preview 07:06

This video explains exception handling in context of constructors and destructors.

Exception Handling - Part VI - (noexcept keyword in C++11) Preview 08:20

Introduces the noexcept keyword. We learn its purpose and where it should be used.

Quiz

Test your knowledge & understanding of exception handling.

Raw String Literals (C++11) Preview 04:03

Introduces the C++11 raw string literals and explains their purpose & usage. 

Introduction to Filesystem Library (C++17) (DEPRECATED) Preview 03:49

This video gives a glimpse of the features of the filesystem library from the C++17 standard.
Note: Filesystem library components are discussed in depth in the section titled "New Standard Library Components".

File IO - Part I (Basics) Preview 06:44

Introduction to basic file I/O. Demonstrates reading and writing of data into text files.

File IO - Part II (Error Handling) Preview 05:43

This lecture shows how to handle errors during file I/O through stream state flags.

File IO - Part III (Copy Utility) Preview 03:29

Uses file I/O to create a utility that copies text files.

File IO - Part IV (Character IO & Seeking) Preview 07:22

This video explains the following: 

1. How to perform character I/O with streams
2. Jumping to random locations in a file through seek functions
3. Using std::fstream class to perform I/O on the same file.

File IO - Part V (Binary IO) Preview 08:30

In this video, we learn how to perform binary input/output operations on files.

Assignment I Preview 00:22

Assignment on file copy utility

Assignment II Preview 00:15

Additions to the earlier assignment.

File Copy Utility Source Preview 00:05

File copy utility source files.

File IO

This quiz will test your understanding of file I/O concepts.

Source Code Preview 00:03

Source code only.

Introduction to Templates Preview 07:48

Introduces generic programming through templates. You'll also learn the basic syntax of templates and how to write a function template.

Assignment I Preview 00:14

Assignment on basic templates

Template Argument Deduction & Instantiation Preview 06:28

This video explains 

1. How template arguments are deduced
2. How the compiler uses a function template for a particular data type

Assignment II Preview 00:05

Explicit Specialization Preview 05:54

Explains what is explicit specialization and why is it required.

Non-type Template Arguments Preview 07:14

Explains the purpose of non-type template arguments. Then, we use this concept to implement efficient algorithms.

Assignment III Preview 00:13

Perfect Forwarding - Part I (C++11) Preview 07:23

Introduces perfect forwarding, which is a very important concept implemented through R-value references.

Perfect Forwarding - Part II (C++11) Preview 05:32

We understand how perfect forwarding preserves type information of template function arguments.

Variadic Templates - Part I (C++11) Preview 09:47

Gives a gentle introduction to variadic templates. We learn how to write functions that accept arbitrary number of arguments.

Note: You can implement variadic templates easily with C++17 fold expressions. Refer to the section 16 for lecture on fold expressions.

Variadic Templates - Part II (C++11) Preview 04:50

We take a deep dive into the internals of how variadic templates work.

Assignment IV Preview 00:14

Class Templates Preview 08:39

Here, I'll introduce you to class templates. You'll also learn how to decipher the complex declaration/definition of class member functions.

Class Template Explicit Specialization - Part I Preview 05:41

Just like functions, classes can also be specialized, with a few differences. This video gives a gentle introduction of this concept.

Class Template Explicit Specialization - Part II Preview 04:02

In this video, we'll see some more examples of explicit specialization of class templates, that will help you understand and implement specialization easily.

Assignment V Preview 00:09

Class Template Partial Specialization Preview 06:52

Explains the concept of partial specialization of class templates. Also discusses examples of when and where to use it.

Typedef, Type Alias & Alias Templates (C++11) Preview 08:07

We first understand the concept of type definitions & type aliases and then compare them. Then, I explain the concept of type aliases with templates.

Type Traits (C++11) Preview 07:21

Type traits allow introspection of types at compile-time and is a very powerful feature. This lecture shows you a few type traits and how to use them.

static_assert (C++11) Preview 04:19

static_assert can perform a compile-time assertion. This lecture shows how to use it.

Templates

Test your knowledge & understanding of templates.

Lambda Expressions Source Code Preview 00:03

Source code of the demos

Callbacks Revisited - Function Pointers Preview 06:39

Revisits the concepts of function pointers as callbacks.

Callbacks - Function Objects Preview 06:57

Introduces function objects as callbacks and explains why they're better than function pointers.

Lambda Expressions Preview 04:36

Gives a gentle introduction of lambda expressions and shows how they replace function objects. Also explains the optional specifiers and auto return type.

Lambda Expressions - Internals Preview 05:01

Underestand how lambda expressions are implemented internally.

Lambda Expressions Capture List - Part I Preview 08:25

Introduces the capture list.

Lambda Expressions Capture List - Part II Preview 04:08

Capture list is explained in depth with default modes.

Lambda Expressions Capture List - Part III Preview 05:57

This lecture discusses how to capture class members through this pointer.

Generalized Lambda Capture Preview 04:33

Assignment Preview 00:14

Assignment on function objects and lambda expressions.

Quiz

Test your knowledge of callbacks, function objects & lambda expressions.

Introduction Preview 02:50

Introduces the components of the STL.

std::array (C++11) Preview 04:02

Learn the features of std::array and compare it with in-built static arrays.

std::vector Preview 04:38

Understand how to use a vector as a dynamic array.

std::deque Preview 02:21

Learn what a double-ended queue is and what are its features.

std::list & std::forward_list (C++11) Preview 04:59

Understand the basics of the std::list. Learn about its features and capabilities. This video also explains the std::forward_list that was introduced in C++11.

Sequence Containers Demo Code Preview 00:02

Code only

std::set & std::multiset Preview 05:42

This video starts with associative containers, set & multiset. Learn about their features and understand how to use them.

std::map & std::multimap Preview 07:35

map & multimap are part of associative containers, but store key-value pair instead. Learn about the features of these classes and how to use them.

Associative Containers Demo Code Preview 00:03

Code only

Unordered Containers (C++11) - I Preview 04:38

Unordered containers were added in C++11. This lecture explains their internal structure.

Unordered Containers (C++11) - II Preview 05:48

Demonstrates usage of unordered containers.

std::hash (C++11) Preview 03:48

Demonstrates how to write a custom hash function and equality function object for unordered containers.

Unordered Containers Demo Code Preview 00:02

Code only.

Big O Notation & Performance of Containers Preview 05:04

In this video, I explain the Big-O notation and how that is used to gauge performance of common operations of containers and algorithms.

Algorithms - Part I Preview 08:15

Introduction to common algorithms.

Algorithms - Part II Preview 07:04

Demonstrates how common algorithms can be customized with functions objects and lambda expressions.

Container Changes in C++11 - I Preview 06:33

Learn about the changes to containers in C++11. This lesson discusses the emplace functions.

Container Changes in C++11 - II Preview 04:06

Learn why it is important to use noexcept specifier on move operations.

Container Changes in C++11 - III Preview 06:20

Learn about the new vector functions and their usage.

Container Changes in C++11 - IV Preview 02:28

Learn about the C++20 std::erase function and its usage.

Container Changes in C++11 - V Preview 07:00

Learn & understand the usage of new functions in associative containers.

STL Project Preview 00:20

Assignment that will test your knowledge of STL & algorithms.

Quiz

Tests your knowledge and understanding of STL & algorithms

Concurrency Source Code Preview 00:03

Contains the source code of the demos used in the videos.

Concurrency Basics Preview 05:43

Explains why concurrency is required with an example of a console & user-interface application

Thread Creation (std::thread) Preview 05:47

In this video, you'll learn how to use the std::thread class to create a thread. 

Passing Arguments To Threads Preview 04:18

Learn how to pass arguments to thread functions. 

Thread Synchronization (std::mutex) Preview 06:17

This video explains what happens when data is shared between threads. You'll also learn threading issues such as race condition & deadlock and how to avoid such cases. 

std::lock_guard Preview 02:45

You'll learn why lock_guard class is important and how to use it with mutex.

std::thread Functions & std::this_thread Namespace Preview 07:48

Explains other functions of the thread class. Also explains the std::this_thread namespace and its purpose.

Task Based Concurrency - Part I Preview 05:07

Introduces the std::async function that is used for task based concurrency.

Task Based Concurrency - Part II Preview 03:44

This lectures explains std;:async in more depth.

Launch Policies Preview 04:38

Understand what launch policies are and how to use them in std::async.

std::future Wait Functions Preview 05:07

Understand the different types of wait functions provided by std::future and how to use them.

Using std::promise Preview 05:36

This lecture explains std::promise in depth and how to use it to pass data between threads with explicit synchronization.

Propagating Exceptions Across Threads Preview 03:15

std::promise allows propagating exceptions across threads easily, without any effort on the part of the programmer. This lecture demonstrates how.

Source Code Information Preview 00:14

Read about where source code is uploaded in lectures

Deprecated & Removed Features Preview 03:53

This lecture explains which features were removed in C++17 standard.

Changes Preview 03:12

Some existing features of C++11/14 were fixed and made more flexible. Learn about those changes in this lecture.

Attributes Preview 05:58

Learn about the attributes added in C++11, C++14 & C++17 and how they can be used in code.

Feature Test Macros Preview 05:51

Introduces the __has_include macro to test for existence of a particular header file.

If & switch With Initialization Preview 07:56

Learn how you can perform initialization in if/switch conditions.

inline Variables Preview 05:45

Learn how to use inline variables at global and class scope.

Nested Namespaces Preview 01:51

Learn about this convenient feature of namespaces that simplifies the syntax of creating nested namespaces.

noexcept Preview 03:35

Understand why noexcept is part of the function type in C++17.

constexpr Lambda Preview 07:47

Learn about the changes in lambda expressions in C++17.

Structured Bindings Preview 08:07

Understand how to use structured bindings to bind variables to different members of an object or an array.

Expression Evaluation Order Preview 06:36

Learn and understand the issues with unspecified expression evaluation order and how C++17 fixes it.

Mandatory Copy Elision - I Preview 04:28

This lecture builds up the base for understand mandatory copy elision. It shows the limitation of copy elision in pre-C++17 standards.

Mandatory Copy Elision - II Preview 04:33

This lecture explains mandatory copy elision introduced in C++17. Even without copy & move constructors, you can initialize objects with rvalues.

Class Template Argument Deduction (CTAD) Preview 05:41

Understand and use CTAD to simplify the construction syntax of class templates.

Folding Basics Preview 04:05

Understand the concept of folding and how variadic function templates can be used to implement it.

Fold Expressions - Unary Folds Preview 04:27

Understand how C++17 simplifies folding through fold expressions. In this lecture, we'll see how to perform unary folds.

Fold Expressions - Binary Folds Preview 05:51

This lecture demonstrates how to use binary folds.

Fold Expressions - Recap Preview 02:34

In this lecture, I'll show you how variadic templates & fold expressions are expanded by the compiler. We'll take help of cppinsights.io that shows how many C++ features are expanded and implemented by a C++ compiler.

Type Traits Suffixes Preview 03:22

C++14 & C++17 added suffixes to type traits to simplify there usage. Learn how to use these suffixes in this lecture.

Note: Watch Lecture 137 for introduction to type traits.

if constexpr - I Preview 07:42

Understand how compile time if (if constexpr) performs conditional checks at compile time, thereby improving the performance of your code.

if constexpr - II Preview 04:42

This lecture shows the internals of how the conditional statements are discarded with compile time if expressions.

std::optional - I Preview 05:18

This lecture explains the basics of how to use std::optional.

std::optional - II Preview 03:50

Understand how to use std::optional to represent return type of functions that may not return a value everytime.

std::optional - III Preview 03:38

This lecture explains how to std::optional as a member variable of a class.

std::variant - I Preview 05:57

In this lecture, you'll learn what a variant and how it is better than a union. You'll also learn the different ways a variant member can be initialized & modified.

std::variant - II Preview 04:34

We'll examine construction & initialization of variant members in depth.

std::variant - III Preview 05:58

You'll learn how to use the visitor to read or modify active members in a variant.

std::any Preview 06:33

Learn how to use std::any to store arbitrary types with type safety.

std::string_view - I Preview 08:39

Learn & understand the basics of std::string_view class.

std::string_view - II Preview 08:13

In this lecture, you'll understand the different situations where std::string_view should be and should not be used.

Filesystem - path Preview 05:49

This lecture introduces filesystem library components. You'll learn about the path class that is used with most functions in the filesystem library.

Filesystem - directory_entry Preview 07:00

In this lecture, you'll understand the usage of directory_entry class.

Filesystem - Directory Functions Preview 05:09

This lecture demonstrates the usage of directory manipulation functions for operations such as create, remove, etc.

Filesystem - Permissions Preview 05:44

You'll learn how to get and set permissions on files in Windows & Linux

Parallel Algorithms - I Preview 03:49

In this lecture, you'll get introduced to the parallel algorithms introduced in C++17. Understand how they differ from the regular algorithms.

Parallel Algorithms - II Preview 07:32

This lecture demonstrates usage of parallel algorithms and how they can improve the performance of your code. See the performance gain by comparing sequential and parallel algorithms with multiple examples.

Parallel Algorithms - III Preview 04:24

This lecture explains why parallel algorithms cannot be used everywhere.

BONUS LECTURE Preview 00:01