CCNA 200-301 Pearson uCertify Network Simulator
Cisco 200-301-SIMULATOR.AB1
CCNA 200-301 Pearson uCertify Network Simulator
ISBN: 978-1-61691-837-8Cisco 200-301-SIMULATOR.AB1
C++ All-in One
(C-PLUS.AE1) / ISBN : 978-1-64459-517-6
This course includes
Interactive Lessons
Hands-On Labs
AI Tutor (Add-on)
About This Course
Skills You’ll Get
Interactive Lessons
36+ Interactive Lessons | 70+ Exercises | 177+ Quizzes | 175+ Flashcards | 175+ Glossary of terms
Hands-On Labs
68+ LiveLab | 7+ Video tutorials | 14+ Minutes
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
