uCertify

C++ All-in One

Strengthen your programming skills! Learn C programming concepts, syntax, and best practices. 

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

About This Course

C Primer Plus is a skill development training course that focuses on the core concepts, syntax, and structure of C programs. The course offers a structured and engaging introduction focusing on the concepts, syntax, and best practices of C programming. The course content is divided into 18 comprehensive chapters, each covering different aspects of C programming fundamentals with detailed explanations and hands-on exercises to reinforce your learning. By the end of this C Programming course, you will develop a strong foundation in C programming and acquire the skills required to build applications.

Skills You’ll Get

  • Knowledge of basic syntax, grammar, and structure of C programs
  • Skilled in using various data types (int, float, char, etc.)
  • Declaring, initializing, and using variables and constants 
  • Ability to work with operators including arithmetic, relational, logical, and bitwise
  • Using conditional statements, loops, and branching 
  • Use of functions for creating, calling, and passing arguments 
  • Pointers, their dereferencing, and their use in memory management and dynamic data structures
  • Using one-dimensional and multidimensional arrays
  • Manipulating strings using standard library functions and custom implementations
  • Expertise with File I/O and memory management
  • Defining and using structures and unions for complex data 
  • Preprocessor directives for conditional compilation, macro definitions, and file inclusion
  • Understanding of the C standard library functions and its usage
  • Implement dynamic data structures including linked lists, stacks, queues, and trees
  • Identify and debug errors in C code
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

Any questions?
Check out the FAQs

If you still have any unanswered questions, read this section to resolve all your doubts on ‘C Primer Plus’ study guide.

Contact Us Now

This course offers a comprehensive introduction to the C Programming language.It covers a wide range of topics including fundamentals of programming; functions & pointers; arrays & strings; structures & unions; data types; operators, control flow, and memory management. To summarize, you’ll learn everything you need to know to become a skilled C programmer.

Yes, this course is definitely worth your time and investment. It will provide you with solid foundational knowledge needed to aim for a rewarding career in the programming field.

Yes, it is a beginner-friendly course. You can gradually build on your programming skills as the course progresses.

Yes, this course covers a wide range of advanced topics of programming including pointers & memory management, structures & unions, File I/O, preprocessor directives, standard library, and data structures.

Doing this C Primer Plus online course can open many job opportunities especially in the fields that require strong programming language skills and system-level understanding. It will also improve your problem-solving skills with logical thinking. You’ll have the competitive advantage to aim for high-paying jobs.

You can explore a wide range of career opportunities in the field of systems programming, game development, scientific computing, web development, and embedded systems.

Yes, you will get a certificate of completion after attempting the final assessment.

Related Courses

All Courses