C++17 Core Language Features | Complete Modern C++ (C++11/14/17)

Book Overview & Buying
Table Of Contents

Complete Modern C++ (C++11/14/17)

By : Umar Lone

Buy this Video

Complete Modern C++ (C++11/14/17)

By: Umar Lone

Buy this Video

Overview of this book

This course provides an extensive exploration of C++. The journey starts with mastering the syntax and functionalities of C++ such as variables, loops, and functions, and progresses through more complex concepts like object-oriented programming, where you’ll explore classes, inheritance, and polymorphism. Special attention is given to the nuances of pointers, memory management, and constructors for robust application development. As the course unfolds, you'll delve into advanced C++11/14/17 features, including move semantics, lambda expressions, and smart pointers, which are essential for modern C++ developers looking to enhance performance and manageability of their code. Exception handling and file I/O operations ensure that you can handle data and errors gracefully. Further sections focus on the STL, where you will learn to utilize powerful library functions and containers that can dramatically simplify data handling and processing tasks. We will also cover C++ concurrency, teaching you to write multithreaded software that is both efficient and safe. You'll also explore C++17's new features which simplify code and improve performance, along with detailed discussions on template programming. By the end of this course, you will have a solid understanding of C++'s capabilities and how to apply them to solve real-world problems.

Start Here

Introduction

Visual Studio 2015 Installation (Deprecated)

Visual Studio 2017 Installation (Deprecated)

Visual Studio 2019 Installation

Code::Blocks Installation

Cevelop Installation

XCode Installation on MacOS

Basic Language Facilities

What Is C++?

First C++ Program

The C++ Compilation Process

Primitive Types and Variables

Basic Input/Output

Functions Basics - Part I

Functions Basics - Part II

Overview of Debugging in Visual Studio

Uniform Initialization (C++11)

Pointers

Reference

Reference Versus Pointer

The const Qualifier

The const Qualifier and Compound Types

Automatic Type Inference (C++11)

Range-Based For Loop - I (C++11)

Range-Based For Loop - II (C++11)

Function Overloading

Default Function Arguments

Inline Functions

Function Pointers

Namespace

Memory Management – Part I

Dynamic Memory Allocation - Part I (malloc Function)

Dynamic Memory Allocation - Part II (New Operator)

Dynamic Memory Allocation - Part III (new[] Operator)

Dynamic Memory Allocation - Part IV (2D Arrays)

Classes and Objects

Object-Oriented Programming Basics

Class

Constructor and Destructor

Structures

Non-Static Data Member Initializers (C++11)

this Pointer

Constant Member Functions

Static Class Members

Copy Constructor - Part I

Copy Constructor - Part II

Delegating Constructors (C++11)

Default and Deleted Functions (C++11)

Move Semantics

Value Categories

Move Semantics – Basics (C++11)

Move Semantics – Implementation (C++11)

Rule of 5 and 0

Copy Elision

std::move Function

Operator Overloading

Operator Overloading - Part I (Basics)

Operator Overloading - Part II (Assignment Operator)

Operator Overloading - Part III (Global Overloads)

Operator Overloading - Part IV (Friend Keyword)

Operator Overloading - Part V (Smart Pointer Basics)

Operator Overloading - Part VI (Smart Pointers in C++11)

Operator Overloading - Part VII (Rules)

Type Conversions - Part I (Basics)

Type Conversions - Part II (Primitive to User Type)

Type Conversions - Part III (User to Primitive Type)

Type Conversions - Part IV (User Defined to User Defined)

Initialization Versus Assignment and Member Initialization List

Memory Management – Part II

Raw Pointers

std::unique_ptr

Sharing Pointers

Sharing std::unique_ptr

std::shared_ptr

Weak Ownership

std::weak_ptr Internals

Circular References

Deleter

Dynamic Arrays

Make Functions

More C++ Goodies

Enums - Part I (Basics)

Enums - Part II (Scoped Enums C++11)

Strings - Part I (Raw Strings)

Strings - Part II (std::string)

Strings - Part III (String Streams)

User-Defined Literals

Constant Expressions - constexpr (C++11)

std::initializer_list (C++11)

Dynamic Array (std::vector)

Union - I

Union - II

Object-Oriented Programming

Inheritance and Composition

Inheritance and Access Modifiers

Project - Part I (Beginning)

Project - Part II (Account and Savings Implementation)

Project - Part III (Inheriting Constructors)

Project - Part IV (Virtual Keyword)

Project - Part V (Virtual Mechanism Internals - I)

Project - Part VI (Virtual Mechanism Internals - II)

Project - Part VII (override and final specifier)

Project - Part VIII (Object Slicing)

Project - Part IX (typeid Operator)

Project – Part X (dynamic_ cast Operator)

Abstract Class

Multiple (Diamond) Inheritance

Exception Handling

Exception Handling - Part I (Basics)

Exception Handling - Part II (Multiple Catch Blocks)

Exception Handling - Part III (Stack Unwinding)

Exception Handling - Part IV (Nested Exceptions)

Exception Handling - Part V (Constructor and Destructor)

Exception Handling - Part VI (noexcept Keyword in C++11)

File Input and Output

Raw String Literals (C++11)

Introduction to Filesystem Library (C++17)

File IO - Part I (Basics)

File IO - Part II (Error Handling)

File IO - Part III (Copy Utility)

File IO - Part IV (Character IO and Seeking)

File IO - Part V (Binary IO)

Templates

Introduction to Templates

Template Argument Deduction and Instantiation

Explicit Specialization

Non-type Template Arguments

Perfect Forwarding - Part I (C++11)

Perfect Forwarding - Part II (C++11)

Variadic Templates - Part I (C++11)

Variadic Templates - Part II (C++11)

Class Templates

Class Template Explicit Specialization - Part I

Class Template Explicit Specialization - Part II

Class Template Partial Specialization

Typedef, Type Alias, and Alias Templates (C++11)

Type Traits (C++11)

static_assert (C++11)

Lambda Expressions (C++11)

Callbacks Revisited - Function Pointers

Callbacks - Function Objects

Lambda Expressions

Lambda Expressions - Internals

Lambda Expressions Capture List - Part I

Lambda Expressions Capture List - Part II

Lambda Expressions Capture List - Part III

Generalized Lambda Capture

Standard Template Library

Introduction

std::array (C++11)

std::vector

std::deque

std::list and std::forward_list (C++11)

std::set and std::multiset

std::map and std::multimap

Unordered Containers (C++11) - I

Unordered Containers (C++11) - II

std::hash (C++11)

Big O Notation and Performance of Containers

Algorithms - Part I

Algorithms - Part II

C++ Concurrency

Concurrency Basics

Thread Creation (std::thread)

Passing Arguments to Threads

Thread Synchronization (std::mutex)

std::lock_guard

std::thread Functions and std::this_thread Namespace

Task-Based Concurrency - Part I

Task-Based Concurrency - Part II

Launch Policies

std::future Wait Functions

Using std::promise

Propagating Exceptions Across Threads

C++17 Core Language Features

Deprecated and Removed Features

Changes

Attributes

Feature Test Macros

If and switch with Initialization

Inline Variables

Nested Namespaces

noexcept

constexpr Lambda

Structured Bindings

Expression Evaluation Order

Mandatory Copy Elision - I

Mandatory Copy Elision - II

C++17 Template Features

Compiled Time Argument Deduction (CTAD)

Folding Basics

Fold Expressions - Unary Folds

Fold Expressions - Binary Folds

Fold Expressions - Recap

Type Traits Suffixes

if constexpr - I

if constexpr - II

Function Wrappers

std::function – I

std:;function – II

std::bind – I

std::bind – II

std::bind - III

C++17 Standard Library Components

std::optional - I

std::optional - II

std::optional - III

std::variant - I

std::variant - II

std::variant - III

std::any

std::string_view - I

std::string_view - II

Filesystem - path

Filesystem - directory_entry

Filesystem - Directory Functions

Filesystem - Permissions

Parallel Algorithms - I

Parallel Algorithms - II

Parallel Algorithms - III

Complete Modern C++ (C++11/14/17)

By : Umar Lone

Complete Modern C++ (C++11/14/17)

By: Umar Lone

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access