Complete Modern C C111417

Complete Modern C C111417

What you’ll learn

Use C++ as an object-oriented language
Demystify function & class templates
Use STL components in your applications
Write real-world applications in C++
Apply Modern C++ (C++11/14/17) in programs

Requirements

Basic programming knowledge in any computer language
Some experience of writing programs in any language
Modern C++ compiler, preferably Visual Studio 2015/17/19 Community (or XCode, Clang, g++, Cevelop, Eclipse CDT, Code::Blocks)

Description

Learn C++ in depth with modern features introduced with C++11/14/17Updated with C++17 features!C++ is a general purpose programming language invented by Bjarne Stroustrup. It is still one of the more popular programming languages, used for creating high performance applications across a wide variety of domains & platforms.In 2011, C++11 was born. This revision added lot of new features to the language and it got a new name, Modern C++. This emphasizes writing C++ code using modern features of the language such as move semantics, automatic type inference, threading, lambda expressions, smart pointers and a lot more. C++11 was followed by C++14, that added even more features and enhanced existing ones. C++17 released in 2017 added a filesystem library (covered in the course), parallel versions of STL algorithms, new library types such as std::optional, std::any and more.This course teaches C++ as an object oriented language with modern features. It focuses on teaching C++ concepts, both old and new, with clear examples. It builds upon the basic language facilities that are then used to build more complex programs with classes, operator overloading, composition, inheritance, polymorphism, templates, concurrency, etc. It even digs deep into assembly to understand few concepts better. After every few topics, a quiz is presented that tests your understanding of the previous topics. Have fun learning Modern C++.Note that this course is not for you ifYou have never programmed beforeYou don’t know ANY programming languageYou want to learn basics of programmingUpdate [April 19, 2020] : Biggest update so far. Added C++17 core language changes, template enhancement and new library types.Update [April 11, 2020] : Added content on copy elision, type traits, static_assert & generalized lambda capture, C++11 unionsUpdate [Mar 25, 2020]: XCode installation & high-level concurrency (std::async)Update [Mar 1, 2019] : More videos added for memory management with smart pointers (shared_ptr, unique_ptr, weak_ptr_)Update [Oct 19, 2017] :Instructions added for installing Visual Studio Community 2017, Cevelop (Eclipse) & Code::BlocksUpdate [Sep 29, 2107] : Added more content on dynamic memory allocation (malloc, new[], 2D arrays, strings)Update [Sep 16, 2017] : C++ concurrency (std::thread, std::mutex, etc)Update [April 27, 2017] : Templates, Function Object, Lambda Expressions, Standard Template LibraryUpdate [Mar 23, 2017] : Virtual Inheritance, Exception handling, File I/O, std::filesystem (C++17)Update [Mar 4, 2017] : Strings, stringstreams, enums, inheritance, polymorphismUpdate [Feb 25, 2017] : Source Code of existing topics added

Overview

Section 1: Start Here

Lecture 1 Introduction

Lecture 2 Source Code

Lecture 3 Required software

Lecture 4 Visual Studio 2015 Installation (DEPRECATED)

Lecture 5 Visual Studio 2017 Installation (DEPRECATED)

Lecture 6 Visual Studio 2019 Installation

Lecture 7 Code::Blocks Installation

Lecture 8 Cevelop Installation

Lecture 9 XCode Installation on MacOS

Lecture 10 Course Slides

Section 2: Basic Language Facilities

Lecture 11 What is C++?

Lecture 12 First C++ Program

Lecture 13 The C++ Compilation Process

Lecture 14 Primitive Types & Variables

Lecture 15 Basic Input/Output

Lecture 16 Functions Basics – Part I

Lecture 17 Functions Basics – Part II

Lecture 18 Overview of Debugging in Visual Studio

Lecture 19 Uniform Initialization (C++11)

Lecture 20 Pointers

Lecture 21 Assignment

Lecture 22 Reference

Lecture 23 Assignment

Lecture 24 Reference Vs Pointer

Lecture 25 The const Qualifier

Lecture 26 const Qualifer & Compound Types

Lecture 27 Assignment

Lecture 28 Automatic Type Inference (C++11)

Lecture 29 Range-Based For Loop – I (C++11)

Lecture 30 Range-Based For Loop – II (C++11)

Lecture 31 Function Overloading

Lecture 32 Default Function Arguments

Lecture 33 Inline Functions

Lecture 34 Function Pointers

Lecture 35 Namespace

Section 3: Memory Management – Part I

Lecture 36 Dynamic Memory Allocation – Part I (malloc function)

Lecture 37 Dynamic Memory Allocation – Part II (new operator)

Lecture 38 Dynamic Memory Allocation – Part III (new[] operator)

Lecture 39 Dynamic Memory Allocation – Part IV (2D arrays)

Lecture 40 Dynamic Memory Allocation – Source Code Only

Section 4: Classes & Objects

Lecture 41 Object Oriented Programming Basics

Lecture 42 Class

Lecture 43 Constructor & Destructor

Lecture 44 Structures

Lecture 45 Non-static Data Member Initializers (C++11)

Lecture 46 this Pointer

Lecture 47 Static Class Members

Lecture 48 Constant Member Functions

Lecture 49 Copy Constructor – Part I

Lecture 50 Copy Constructor – Part II

Lecture 51 Delegating Constructors (C++11)

Lecture 52 Default & Deleted Functions (C++11)

Section 5: Move Semantics

Lecture 53 L-values, R-values & R-value References (C++11)

Lecture 54 Move Semantics – Basics (C++11)

Lecture 55 Move Semantics – Implementation (C++11)

Lecture 56 Rule of 5 & 0

Lecture 57 Copy Elision

Lecture 58 std::move Function (C++11)

Section 6: Operator Overloading

Lecture 59 Operator Overloading Demo Code

Lecture 60 Operator Overloading – Part I (Basics)

Lecture 61 Operator Overloading – Part II (Assignment Operator)

Lecture 62 Operator Overloading – Part III (Global Overloads)

Lecture 63 Operator Overloading – Part IV (Friend Keyword)

Lecture 64 Operator Overloading – Part V (Smart Pointer Basics)

Lecture 65 Operator Overloading – Part VI (Smart Pointers in C++11)

Lecture 66 Operator Overloading – Part VII (Rules)

Lecture 67 Type Conversions – Part I (Basics)

Lecture 68 Type Conversions – Part II (Primitive to User Type)

Lecture 69 Type Conversions – Part III (User to Primitive Type)

Lecture 70 Type Conversions – Part IV (User Defined to User Defined)

Lecture 71 Initialization Vs. Assignment & Member Initialization List

Section 7: Memory Management – Part II

Lecture 72 Raw Pointers

Lecture 73 std::unique_ptr

Lecture 74 Sharing Pointers

Lecture 75 Sharing std::unique_ptr

Lecture 76 std::shared_ptr

Lecture 77 Weak Ownership

Lecture 78 std::weak_ptr Internals

Lecture 79 Circular References

Lecture 80 Deleter

Lecture 81 Dynamic Arrays

Lecture 82 Make Functions

Section 8: More C++ Goodies

Lecture 83 Enums – Part I (Basics)

Lecture 84 Enums – Part II (Scoped Enums C++11)

Lecture 85 Strings – Part I (Raw Strings)

Lecture 86 Strings – Part II (std::string)

Lecture 87 Assignment I

Lecture 88 Strings – Part III (String Streams)

Lecture 89 Assignment II

Lecture 90 User-Defined Literals

Lecture 91 Constant Expressions – constexpr (C++11)

Lecture 92 std::initializer_list (C++11)

Lecture 93 Dynamic Array (std::vector)

Lecture 94 Assignment III

Lecture 95 Union – I

Lecture 96 Union – II

Section 9: Object Oriented Programming

Lecture 97 Account Hierarchy Source Code

Lecture 98 Inheritance & Composition

Lecture 99 Inheritance & Access Modifiers

Lecture 100 Project – I (Introduction)

Lecture 101 Project – II (Account & Savings Class)

Lecture 102 Assignment

Lecture 103 Project – III (C++11 Inheriting Constructors)

Lecture 104 Project – IV (Virtual Keyword)

Lecture 105 Project -V (Virtual Mechanism Internals – I)

Lecture 106 Project -VI (Virtual Mechanism Internals – II)

Lecture 107 Project – Part VIII (override & final specifier in C++11)

Lecture 108 Project – VIII (Object Slicing)

Lecture 109 Project – IX (typeid Operator)

Lecture 110 Project – Part X (dynamic_cast Operator)

Lecture 111 Abstract Class

Lecture 112 Multiple (Diamond) Inheritance

Section 10: Exception Handling

Lecture 113 Exception Handling – Part I (Basics)

Lecture 114 Exception Handling – Part II (Multiple Catch Blocks)

Lecture 115 Exception Handling – Part III (Stack Unwinding)

Lecture 116 Exception Handling – Part IV (Nested Exceptions)

Lecture 117 Exception Handling – Part V (Constructor & Destructor)

Lecture 118 Exception Handling – Part VI – (noexcept keyword in C++11)

Section 11: File Input & Output

Lecture 119 Raw String Literals (C++11)

Lecture 120 Introduction to Filesystem Library (C++17) (DEPRECATED)

Lecture 121 File IO – Part I (Basics)

Lecture 122 File IO – Part II (Error Handling)

Lecture 123 File IO – Part III (Copy Utility)

Lecture 124 File IO – Part IV (Character IO & Seeking)

Lecture 125 File IO – Part V (Binary IO)

Lecture 126 Assignment I

Lecture 127 Assignment II

Lecture 128 File Copy Utility Source

Section 12: Templates

Lecture 129 Source Code

Lecture 130 Introduction to Templates

Lecture 131 Assignment I

Lecture 132 Template Argument Deduction & Instantiation

Lecture 133 Assignment II

Lecture 134 Explicit Specialization

Lecture 135 Non-type Template Arguments

Lecture 136 Assignment III

Lecture 137 Perfect Forwarding – Part I (C++11)

Lecture 138 Perfect Forwarding – Part II (C++11)

Lecture 139 Variadic Templates – Part I (C++11)

Lecture 140 Variadic Templates – Part II (C++11)

Lecture 141 Assignment IV

Lecture 142 Class Templates

Lecture 143 Class Template Explicit Specialization – Part I

Lecture 144 Class Template Explicit Specialization – Part II

Lecture 145 Assignment V

Lecture 146 Class Template Partial Specialization

Lecture 147 Typedef, Type Alias & Alias Templates (C++11)

Lecture 148 Type Traits (C++11)

Lecture 149 static_assert (C++11)

Section 13: Lambda Expressions (C++11)

Lecture 150 Lambda Expressions Source Code

Lecture 151 Callbacks Revisited – Function Pointers

Lecture 152 Callbacks – Function Objects

Lecture 153 Lambda Expressions

Lecture 154 Lambda Expressions – Internals

Lecture 155 Lambda Expressions Capture List – Part I

Lecture 156 Lambda Expressions Capture List – Part II

Lecture 157 Lambda Expressions Capture List – Part III

Lecture 158 Generalized Lambda Capture

Lecture 159 Assignment

Section 14: Standard Template Library

Lecture 160 Introduction

Lecture 161 std::array (C++11)

Lecture 162 std::vector

Lecture 163 std::deque

Lecture 164 std::list & std::forward_list (C++11)

Lecture 165 Sequence Containers Demo Code

Lecture 166 std::set & std::multiset

Lecture 167 std::map & std::multimap

Lecture 168 Associative Containers Demo Code

Lecture 169 Unordered Containers (C++11) – I

Lecture 170 Unordered Containers (C++11) – II

Lecture 171 std::hash (C++11)

Lecture 172 Unordered Containers Demo Code

Lecture 173 Big O Notation & Performance of Containers

Lecture 174 Algorithms – Part I

Lecture 175 Algorithms – Part II

Lecture 176 Container Changes in C++11 – I

Lecture 177 Container Changes in C++11 – II

Lecture 178 Container Changes in C++11 – III

Lecture 179 Container Changes in C++11 – IV

Lecture 180 Container Changes in C++11 – V

Lecture 181 STL Project

Section 15: C++ Concurrency

Lecture 182 Concurrency Source Code

Lecture 183 Concurrency Basics

Lecture 184 Thread Creation (std::thread)

Lecture 185 Passing Arguments To Threads

Lecture 186 Thread Synchronization (std::mutex)

Lecture 187 std::lock_guard

Lecture 188 std::thread Functions & std::this_thread Namespace

Lecture 189 Task Based Concurrency – Part I

Lecture 190 Task Based Concurrency – Part II

Lecture 191 Launch Policies

Lecture 192 std::future Wait Functions

Lecture 193 Using std::promise

Lecture 194 Propagating Exceptions Across Threads

Section 16: C++17 Core Language Features

Lecture 195 Source Code Information

Lecture 196 Deprecated & Removed Features

Lecture 197 Changes

Lecture 198 Attributes

Lecture 199 Feature Test Macros

Lecture 200 If & switch With Initialization

Lecture 201 inline Variables

Lecture 202 Nested Namespaces

Lecture 203 noexcept

Lecture 204 constexpr Lambda

Lecture 205 Structured Bindings

Lecture 206 Expression Evaluation Order

Lecture 207 Mandatory Copy Elision – I

Lecture 208 Mandatory Copy Elision – II

Section 17: C++17 Template Features

Lecture 209 Class Template Argument Deduction (CTAD)

Lecture 210 Folding Basics

Lecture 211 Fold Expressions – Unary Folds

Lecture 212 Fold Expressions – Binary Folds

Lecture 213 Fold Expressions – Recap

Lecture 214 Type Traits Suffixes

Lecture 215 if constexpr – I

Lecture 216 if constexpr – II

Section 18: C++17 Standard Library Components

Lecture 217 std::optional – I

Lecture 218 std::optional – II

Lecture 219 std::optional – III

Lecture 220 std::variant – I

Lecture 221 std::variant – II

Lecture 222 std::variant – III

Lecture 223 std::any

Lecture 224 std::string_view – I

Lecture 225 std::string_view – II

Lecture 226 Filesystem – path

Lecture 227 Filesystem – directory_entry

Lecture 228 Filesystem – Directory Functions

Lecture 229 Filesystem – Permissions

Lecture 230 Parallel Algorithms – I

Lecture 231 Parallel Algorithms – II

Lecture 232 Parallel Algorithms – III

Lecture 233 BONUS LECTURE

College students who want to learn Modern C++,Expert C++ developers who want to migrate to Modern C++,C++ developers with varying level of experience, who want to refresh basics of the C++ language and get acquainted with the new features,Software professionals who want to learn & implement Modern C++,Anyone who is comfortable with other languages like C, Java, C#, Python, etc, and wants to learn & apply Modern C++,Anyone interested in learning C++

Course Information:

Udemy | English | 19h 56m | 8.11 GB
Created by: Umar Lone

You Can See More Courses in the Developer >> Greetings from CourseDown.com