C++ All-in One


This course includes
Hands-On Labs
AI Tutor (Add-on)

The C++ All-in-One course is designed to equip you with everything you need to become a proficient C++ developer, whether you're a beginner or looking to enhance your existing skills. The course is structured to provide you with a thorough understanding of C++ programming concepts and techniques. The course covers the key areas such as Introduction to C++, Fundamental Concepts, Object-Oriented Programming, Advanced Topics, Standard Template Library, Project-Based Learning, Debugging and Troubleshooting.


36+ Lessons | 70+ Exercises | 177+ Quizzes | 175+ Flashcards | 175+ Glossary of terms


Hands-On Labs

68+ LiveLab | 7+ Video tutorials | 14+ Minutes

Here's what you will learn

Download Course Outline

Lessons 1: Introduction

  • About This Course
  • Icons Used in This Course
  • Where to Go from Here

Lessons 2: Configuring Your Desktop System

  • Obtaining a Copy of C++ 20
  • Obtaining Code::Blocks
  • Installing Code::Blocks
  • Touring the Essential Code::Blocks Features

Lessons 3: Configuring Your Mobile System

  • Obtaining CppDroid
  • Considering Other Alternatives
  • Touring the Essential CppDroid Features
  • Obtaining CppDroid Help

Lessons 4: Creating Your First C++ Application

  • Code::Blocks Creating a Project
  • Typing the Code
  • Starting with Main
  • Showing Information
  • Let Your Application Run Away

Lessons 5: Storing Data in C++

  • Putting Your Data Places: Variables
  • Manipulating Integer Variables
  • Characters
  • Strings
  • Making Decisions Using Conditional Operators
  • Telling the Truth with Boolean Variables
  • Reading from the Console

Lessons 6: Directing the Application Flow

  • Doing This or Doing That
  • Evaluating Conditions in C++
  • Including Evaluations in C++ Conditional Statements
  • Repeating Actions with Statements That Loop
  • Looping for
  • Looping while
  • Doing while
  • Breaking and continuing
  • Nesting loops

Lessons 7: Dividing Your Work with Functions

  • Dividing Your Work
  • Calling a Function
  • Writing Your Own Functions
  • Improving On the Basic Function
  • Calling All String Functions
  • Understanding main()

Lessons 8: Splitting Up Source Code Files

  • Creating Multiple Source Files
  • Sharing with Header Files
  • Sharing Variables among Source Files
  • Using the Mysterious Header Wrappers

Lessons 9: Referring to Your Data Through Pointers

  • Understanding the Changes in Pointers for C++ 20
  • Heaping and Stacking the Variables
  • Creating New Raw Pointers
  • Freeing Raw Pointers
  • Working with Smart Pointers
  • Passing Pointer Variables to Functions
  • Returning Pointer Variables from Functions

Lessons 10: Working with Classes

  • Understanding Objects and Classes
  • Working with a Class
  • Starting and Ending with Constructors and Destructors
  • Building Hierarchies of Classes
  • Creating and Using Object Aliases

Lessons 11: Using Advanced C++ Features

  • Filling Your Code with Comments
  • Converting Types
  • Reading from the Console
  • Understanding Preprocessor Directives
  • Using Constants
  • Using Switch Statements
  • Supercharging enums with Classes
  • Working with Random Numbers
  • Storing Data in Arrays

Lessons 12: Planning and Building Objects

  • Recognizing Objects
  • Encapsulating Objects
  • Building Hierarchies

Lessons 13: Building with Design Patterns

  • Delving Into Pattern History
  • Introducing a Simple Pattern: the Singleton
  • Watching an Instance with an Observer
  • Mediating with a Pattern

Lessons 14: Considering Functional Programming

  • Understanding How Functional Programming Differs
  • Defining an Impure Language
  • Seeing Data as Immutable
  • Considering the Effects of State
  • Eliminating Side Effects
  • Understanding the Role of auto
  • Passing Functions to Functions
  • Using Lambda Expressions for Implementation

Lessons 15: Working with Lambda Expressions

  • Creating More Readable and Concise C++ Code
  • Defining the Essential Lambda Expression
  • Developing with Lambda Expressions

Lessons 16: Advanced Lambda Expressions

  • Considering the C++ 20 Lambda Extensions
  • Working in Unevaluated Contexts
  • Using Assignable Stateless Lambda Expressions
  • Dealing with Pack Expansions

Lessons 17: Dealing with Bugs

  • It’s Not a Bug. It’s a Feature!
  • Make Your Application Features Look Like Features
  • Anticipating (Almost) Everything
  • Avoiding Mistakes, Plain and Simple

Lessons 18: Debugging an Application

  • Programming with Debuggers
  • Debugging with Different Tools
  • Debugging a Code::Blocks Application with Command-Line Arguments

Lessons 19: Stopping and Inspecting Your Code

  • Setting and Disabling Breakpoints
  • Watching, Inspecting, and Changing Variables

Lessons 20: Traveling About the Stack

  • Stacking Your Data
  • Debugging with Advanced Features

Lessons 21: Working with Arrays, Pointers, and References

  • Building Up Arrays
  • Pointing with Pointers
  • Referring to References

Lessons 22: Creating Data Structures

  • Working with Data
  • Structuring Your Data
  • Naming Your Space

Lessons 23: Constructors, Destructors, and Exceptions

  • Constructing and Destructing Objects
  • Programming the Exceptions to the Rule

Lessons 24: Advanced Class Usage

  • Inherently Inheriting Correctly
  • Using Classes and Types within Classes

Lessons 25: Creating Classes with Templates

  • Templatizing a Class
  • Going Beyond the Basics
  • Parameterizing a Template
  • Typedefing a Template
  • Deriving Templates
  • Templatizing a Function

Lessons 26: Programming with the Standard Library

  • Architecting the Standard Library
  • Containing Your Classes
  • The Great Container Showdown
  • Copying Containers
  • Creating and Using Dynamic Arrays
  • Working with Unordered Data
  • Working with Ranges

Lessons 27: Filing Information with the Streams Library

  • Seeing a Need for Streams
  • Programming with the Streams Library
  • Handling Errors When Opening a File
  • Flagging the ios Flags

Lessons 28: Writing with Output Streams

  • Inserting with the << Operator
  • Formatting Your Output

Lessons 29: Reading with Input Streams

  • Extracting with Operators
  • Encountering the End of File
  • Reading Various Types

Lessons 30: Building Directories and Contents

  • Manipulating Directories
  • Getting the Contents of a Directory
  • Copying Files
  • Moving and Renaming Files and Directories

Lessons 31: Streaming Your Own Classes

  • Streaming a Class for Text Formatting
  • Manipulating a Stream

Lessons 32: Exploring the Standard Library Further

  • Considering the Standard Library Categories
  • Parsing Strings Using a Hash
  • Obtaining Information Using a Random Access Iterator
  • Locating Values Using the Find Algorithm
  • Using the Random Number Generator
  • Working with Temporary Buffers

Lessons 33: Working with User-Defined Literals (UDLs)

  • Understanding the Need for UDLs
  • Working with the UDLs in the Standard Library
  • Creating Your Own UDLs

Lessons 34: Building Original Templates

  • Deciding When to Create a Template
  • Defining the Elements of a Good Template
  • Creating a Basic Math Template
  • Building a Structure Template
  • Developing a Class Template
  • Considering Template Specialization
  • Creating a Template Library
  • Using Your Template Library

Lessons 35: Investigating Boost

  • Considering the Standard Library Alternative
  • Understanding Boost
  • Obtaining and Installing Boost for Code::Blocks
  • Creating the Boost Tools
  • Using Boost.Build
  • Using Inspect
  • Understanding BoostBook
  • Using QuickBook
  • Using bcp
  • Using Wave
  • Building Your First Boost Application Using Date Time

Lessons 36: Boosting up a Step

  • Parsing Strings Using RegEx
  • Breaking Strings into Tokens Using Tokenizer
  • Performing Numeric Conversion
  • Creating Improved Loops Using Foreach
  • Accessing the Operating System Using Filesystem

Hands-on LAB Activities

Creating Your First C++ Application

  • Building and Executing the First C++ Application
  • Adding Two Numbers

Storing Data in C++

  • Making a Calculator
  • Adding Two Strings and Changing a Part of the String
  • Comparing Two Integers Using the Conditional Operator

Directing the Application Flow

  • Using Logical Operators
  • Using the for Loop
  • Using the do-while Loop
  • Using the Nested for Loop

Dividing Your Work with Functions

  • Using the pow() Function
  • Using the PrintName() function

Splitting Up Source Code Files

  • Defining and Calling a Function
  • Adding a New Source Code File

Referring to Your Data Through Pointers

  • Using Pointers to Point to a String
  • Displaying the Allocated Memory
  • Replacing Characters within a String
  • Using Pointers to Modify a Variable Passed into a Function

Working with Classes

  • Using the Public and Private Functions
  • Using the this Variable
  • Using Constructors and Destructors
  • Deriving One Class from Another

Using Advanced C++ Features

  • Performing TypeConversion
  • Using the Switch Statement
  • Creating a Class for enums
  • Adding and Subtracting Pointers

Considering Functional Programming

  • Finding the Factorial of a Number
  • Using the auto Keyword
  • Using Declarative Programming Techniques
  • Using a Transform

Working with Lambda Expressions

  • Demangling a Type Name
  • Using the auto Keyword with Lambda Expressions
  • Sorting Values Using a Lambda Expression

Advanced Lambda Expressions

  • Defining a Priority Queue Comparator
  • Using a Variadic Template

Stopping and Inspecting Your Code

  • Setting a Breakpoint

Traveling About the Stack

  • Calling the Nested Function

Working with Arrays, Pointers, and References

  • Using the sizeof() Function
  • Referencing a Method

Creating Data Structures

  • Calculating the Maximum Value and Size of Data Types
  • Printing the ASCII Values
  • Copying Structures
  • Pulling Names into Other Namespaces

Constructors, Destructors, and Exceptions

  • Using the Copy Constructor
  • Creating a Virtual Destructor
  • Creating a Basic try-catch Block

Advanced Class Usage

  • Using the Friend Function
  • Using Multiple Inheritance

Creating Classes with Templates

  • Creating and Using a Template
  • Using Static Members in a Template
  • Overloading a Function Template

Programming with the Standard Library

  • Iterating Through a map
  • Using Vectors as Container Classes
  • Associating Objects with map
  • Creating a Stack and a Queue

Filing Information with the Streams Library

  • Reading and Writing to a File

Writing with Output Streams

  • Displaying Flag-Formatted Numbers
  • Using the Precision Function
  • Setting the Width and Creating Fields

Reading with Input Streams

  • Using the Extraction Operator

Streaming Your Own Classes

  • Using Manipulators

Exploring the Standard Library Further

  • Generating a Hash
  • Generating Key and Value Pairs

Working with User-Defined Literals (UDLs)

  • Using Prefixes and Suffixes
  • Defining a UDL Operator

Building Original Templates

  • Defining a Series of Function Templates
  • Building a Structure Template

Boosting up a Step

  • Generating Tokens from Strings
  • Using the BOOST_FOREACH Loop