uCertify

C++ All-in One

(C-PLUS.AE1) / ISBN : 978-1-64459-517-6
Lessons
Lab
AI Tutor (Add-on)
Get A Free Trial

About This Course

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.

Skills You’ll Get

Download Course Outline

1

Introduction

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

Configuring Your Desktop System

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

Configuring Your Mobile System

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

Creating Your First C++ Application

  • Code::Blocks Creating a Project
  • Typing the Code
  • Starting with Main
  • Showing Information
  • Let Your Application Run Away
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
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
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()
8

Splitting Up Source Code Files

  • Creating Multiple Source Files
  • Sharing with Header Files
  • Sharing Variables among Source Files
  • Using the Mysterious Header Wrappers
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
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
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
12

Planning and Building Objects

  • Recognizing Objects
  • Encapsulating Objects
  • Building Hierarchies
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
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
15

Working with Lambda Expressions

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

Advanced Lambda Expressions

  • Considering the C++ 20 Lambda Extensions
  • Working in Unevaluated Contexts
  • Using Assignable Stateless Lambda Expressions
  • Dealing with Pack Expansions
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
18

Debugging an Application

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

Stopping and Inspecting Your Code

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

Traveling About the Stack

  • Stacking Your Data
  • Debugging with Advanced Features
21

Working with Arrays, Pointers, and References

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

Creating Data Structures

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

Constructors, Destructors, and Exceptions

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

Advanced Class Usage

  • Inherently Inheriting Correctly
  • Using Classes and Types within Classes
25

Creating Classes with Templates

  • Templatizing a Class
  • Going Beyond the Basics
  • Parameterizing a Template
  • Typedefing a Template
  • Deriving Templates
  • Templatizing a Function
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
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
28

Writing with Output Streams

  • Inserting with the << Operator
  • Formatting Your Output
29

Reading with Input Streams

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

Building Directories and Contents

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

Streaming Your Own Classes

  • Streaming a Class for Text Formatting
  • Manipulating a Stream
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
33

Working with User-Defined Literals (UDLs)

  • Understanding the Need for UDLs
  • Working with the UDLs in the Standard Library
  • Creating Your Own UDLs
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
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
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

1

Creating Your First C++ Application

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

Storing Data in C++

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

Directing the Application Flow

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

Dividing Your Work with Functions

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

Splitting Up Source Code Files

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

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
7

Working with Classes

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

Using Advanced C++ Features

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

Considering Functional Programming

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

Working with Lambda Expressions

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

Advanced Lambda Expressions

  • Defining a Priority Queue Comparator
  • Using a Variadic Template
12

Stopping and Inspecting Your Code

  • Setting a Breakpoint
13

Traveling About the Stack

  • Calling the Nested Function
14

Working with Arrays, Pointers, and References

  • Using the sizeof() Function
  • Referencing a Method
15

Creating Data Structures

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

Constructors, Destructors, and Exceptions

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

Advanced Class Usage

  • Using the Friend Function
  • Using Multiple Inheritance
18

Creating Classes with Templates

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

Programming with the Standard Library

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

Filing Information with the Streams Library

  • Reading and Writing to a File
21

Writing with Output Streams

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

Reading with Input Streams

  • Using the Extraction Operator
23

Streaming Your Own Classes

  • Using Manipulators
24

Exploring the Standard Library Further

  • Generating a Hash
  • Generating Key and Value Pairs
25

Working with User-Defined Literals (UDLs)

  • Using Prefixes and Suffixes
  • Defining a UDL Operator
26

Building Original Templates

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

Boosting up a Step

  • Generating Tokens from Strings
  • Using the BOOST_FOREACH Loop

C++ All-in One

R 4358.1

Buy Now

Related Courses

All Course
scroll to top