CoursesProgramming

ProgrammingBeginnerSelf-paced

C++ Programming Essentials

This course provides a comprehensive introduction to C++ programming, covering fundamental concepts, object-oriented programming, generic programming, and the standard library. Students will learn to write efficient and effective C++ code. By the end of the course, learners will have a solid understanding of C++ and be able to apply it in various programming contexts.

See the syllabus
140chapters
283modules
604lessons
154quizzes

Syllabus

140 chapters, 283 modules, 758 lessons and quizzes.

  1. 01Getting Started1 modules · 2 lessons

    Getting Started

  2. 02Building Your First C++ Program3 modules · 9 lessons

    C++ Program Fundamentals

    Output and Input/Output Operators

    Functions in C++

  3. 03Understanding Functions in C++2 modules · 6 lessons

    Function Basics

    Code Comprehensibility and Function Overloading

  4. 04Understanding Types, Variables, and Arithmetic Operations4 modules · 11 lessons

    Variables and Types

    Arithmetic Operations and Type Conversions

    Initializing Variables and Auto Keyword

    Compound Assignment Operators

  5. 05Understanding Variable Scope and Lifetime2 modules · 6 lessons

    Variable Scopes in C++

    Variable Lifetime

  6. 06Understanding Constants in C++2 modules · 6 lessons

    Types of Constants

    constexpr Functions

  7. 07Understanding Pointers, Arrays, and References4 modules · 11 lessons

    Array and Pointer Basics

    Using Arrays and Pointers in Loops

    References and Const References

    Null Pointers

  8. 08Writing Testable Code in C++2 modules · 5 lessons

    Conditional Statements for User Input

    Looping Constructs for Repeated Actions

  9. 09Best Practices for the Basics of C++3 modules · 9 lessons

    Writing Effective Functions

    Code Readability and Maintainability

    Pointers and Initialization

  10. 10C++ Types and Abstraction Mechanisms1 modules · 3 lessons

    Understanding C++ Type Systems

  11. 11Defining and Using Structures2 modules · 5 lessons

    Defining and Initializing Structures

    Accessing Struct Members

  12. 12Defining Classes in C++2 modules · 5 lessons

    Class Basics

    Using Classes

  13. 13Understanding Unions in C++2 modules · 6 lessons

    Introduction to Unions

    Best Practices for Using Unions

  14. 14Understanding Enumerations in C++2 modules · 5 lessons

    Introduction to Enumerations

    Working with Enumerations

  15. 15Best Practices for User-Defined Types3 modules · 7 lessons

    Organizing Data and Code

    Initialization and Enumerations

    Avoiding Common Pitfalls

  16. 16Modularizing Code through Separate Compilation1 modules · 1 lessons

    Understanding Separate Compilation

  17. 17Managing Complexity in C++ Programs1 modules · 3 lessons

    Defining Interfaces in C++

  18. 18Organizing Code with Separate Compilation3 modules · 6 lessons

    Understanding Separate Compilation

    Implementing Separate Compilation

    Modularity through Separate Compilation

  19. 19Organizing Code with Namespaces2 modules · 6 lessons

    Understanding Namespaces

    Accessing Names in Namespaces

  20. 20Understanding Namespaces and Using Directives1 modules · 3 lessons

    Namespaces and Using Directives

  21. 21Error Handling Fundamentals2 modules · 4 lessons

    Role of Type System in Error Prevention

    Developing an Error Handling Strategy

  22. 22Handling Runtime Errors with Exceptions3 modules · 5 lessons

    Understanding Exceptions

    Catching and Handling Exceptions

    Best Practices for Exception Handling

  23. 23Understanding Class Invariants and Exception Handling2 modules · 6 lessons

    Class Invariants and Preconditions

    Exception Handling and Invariants

  24. 24Compile-Time Error Checking3 modules · 5 lessons

    Understanding Static Assertions

    Advanced Topics in Static Assertions

    Contrasting Static Assertions and Exceptions

  25. 25Best Practices for Modularity in C++3 modules · 12 lessons

    Organizing Code and Interfaces

    Error Handling Strategies

    Class Design Principles

  26. 26Abstraction and Resource Management in C++2 modules · 4 lessons

    Understanding User-Defined Types

    Representing Computations

  27. 27Understanding Concrete Types in C++2 modules · 4 lessons

    Characteristics of Concrete Types

    Benefits and Usage of Concrete Types

  28. 28Creating User-Defined Arithmetic Types3 modules · 10 lessons

    Defining a Complex Number Class

    Operator Overloading for Complex Numbers

    Using the Complex Number Class

  29. 29Containers and Resource Management1 modules · 4 lessons

    Container Basics and Resource Management

  30. 30Container Initialization Techniques1 modules · 4 lessons

    Initializing Containers

  31. 31Working with Abstract Types4 modules · 8 lessons

    Defining Abstract Types

    Using Abstract Types

    Implementing Abstract Types

    Virtual Destructors

  32. 32Class Hierarchies and Inheritance4 modules · 6 lessons

    Introduction to Class Hierarchies

    Abstract Classes and Interfaces

    Inheritance and Polymorphism

    Managing Resources in Class Hierarchies

  33. 33Benefits of Class Hierarchies2 modules · 8 lessons

    Types of Inheritance Benefits

    Using Class Hierarchies in Practice

  34. 34Navigating Class Hierarchies1 modules · 5 lessons

    Understanding dynamic_cast

  35. 35Preventing Resource Leaks in C++1 modules · 3 lessons

    Understanding Resource Leaks

  36. 36Copy and Move Operations in C++2 modules · 4 lessons

    Default Copy Behavior

    Considerations for Class Design

  37. 37Copying Containers and Resource Handles2 modules · 6 lessons

    Understanding the Need for Custom Copy Semantics

    Implementing Copy Constructor and Copy Assignment

  38. 38Efficient Resource Transfer with Move Semantics1 modules · 5 lessons

    Understanding Move Semantics

  39. 39Mastering Object Lifecycle Operations3 modules · 6 lessons

    Understanding Special Member Functions

    Controlling Implicit Conversions

    Default Implementations and Resource Management

  40. 40Resource Management for Classes2 modules · 8 lessons

    Resource Management Fundamentals

    Advanced Resource Management Techniques

  41. 41Suppressing Default Operations in C++1 modules · 3 lessons

    Understanding the Need to Suppress Default Operations

  42. 42C++ Class Design Best Practices3 modules · 10 lessons

    Designing Classes

    Resource Management and Class Hierarchies

    Special Member Functions

  43. 43Understanding Templates in C++1 modules · 3 lessons

    Introduction to Templates

  44. 44Generalizing Types with Templates1 modules · 2 lessons

    Introduction to Parameterized Types

  45. 45Function Templates in C++1 modules · 3 lessons

    Introduction to Function Templates

  46. 46Generic Programming with Templates2 modules · 6 lessons

    Introduction to Generic Programming

    Concepts in Generic Programming

  47. 47Function Objects and Lambda Expressions3 modules · 8 lessons

    Introduction to Function Objects

    Lambda Expressions

    Applying Function Objects and Lambda Expressions

  48. 48Working with Variable Numbers of Arguments1 modules · 4 lessons

    Understanding Variadic Templates

  49. 49Type Aliases and Template Aliasing2 modules · 6 lessons

    Understanding Type Aliases

    Template Aliases and Container Value Types

  50. 50Understanding Template Compilation2 modules · 4 lessons

    Template Type Checking

    Template Definition and Scope

  51. 51Best Practices for Template Programming4 modules · 10 lessons

    Template Design Principles

    Advanced Template Concepts

    Template Compilation and Limitations

    Additional Template Features

  52. 52C++ Standard Library Essentials1 modules · 3 lessons

    Understanding Standard Library Components

  53. 53Understanding C++ Standard Library Basics2 modules · 4 lessons

    C++ Standard Library Overview

    Best Practices for Using C++ Standard Library

  54. 54Libraries and Standard Library Facilities2 modules · 4 lessons

    Importance of Libraries

    Beyond Standard Library

  55. 55C++ Standard Library Components1 modules · 3 lessons

    Overview of Standard Library Components

  56. 56Using the C++ Standard Library2 modules · 5 lessons

    Accessing Standard Library Facilities

    Overview of Standard Library Headers

  57. 57Best Practices for Using C++ Libraries2 modules · 5 lessons

    Using C++ Libraries Effectively

    Practical Considerations for Using Standard Library Facilities

  58. 58Working with Strings in C++1 modules · 3 lessons

    Understanding Strings

  59. 59Text Manipulation and Regular Expressions Overview2 modules · 3 lessons

    Introduction to Text Manipulation

    Working with Strings

  60. 60String Implementation Details1 modules · 3 lessons

    Understanding String Implementation

  61. 61Working with Regular Expressions in C++2 modules · 4 lessons

    Introduction to Regular Expressions

    Regular Expression Functions and Iterators

  62. 62Regular Expression Searching1 modules · 5 lessons

    Searching with Regular Expressions

  63. 63Understanding Regular Expression Notation2 modules · 8 lessons

    Regular Expression Basics

    Advanced Regular Expression Concepts

  64. 64Using Iterators with Regular Expressions1 modules · 3 lessons

    Regular Expression Iterators

  65. 65Best Practices for Strings and Regular Expressions2 modules · 7 lessons

    String Operations Best Practices

    Regular Expression Best Practices

  66. 66Introduction to C++ I/O Streams1 modules · 3 lessons

    Understanding I/O Streams

  67. 67Output Operations in C++1 modules · 4 lessons

    Using the Output Operator

  68. 68Reading Input in C++2 modules · 6 lessons

    Input Basics

    Reading into Strings

  69. 69Understanding I/O Stream State2 modules · 5 lessons

    Examining I/O Stream State

    Managing I/O Stream Errors

  70. 70Custom Input/Output for User-Defined Types2 modules · 4 lessons

    Defining Custom Output Operations

    Defining Custom Input Operations

  71. 71Output Formatting in C++3 modules · 5 lessons

    Integer Output Formatting

    Floating-Point Output Formatting

    Persistent Formatting Effects

  72. 72Working with File Streams in C++1 modules · 4 lessons

    File Stream Basics

  73. 73Working with String Streams3 modules · 6 lessons

    Introduction to String Streams

    Using String Streams

    Template Argument Deduction

  74. 74Input/Output Best Practices and Container Overview2 modules · 10 lessons

    Input/Output Best Practices

    Container Overview

  75. 75Containers and Data Collections1 modules · 4 lessons

    Introduction to Containers

  76. 76Working with Vectors3 modules · 8 lessons

    Vector Basics

    Manipulating Vectors

    Vector Copying and Moving

  77. 77Vector Elements and Their Types1 modules · 3 lessons

    Vector Element Types

  78. 78Vector Range Checking and Exception Handling2 modules · 6 lessons

    Understanding Range Checking in Vectors

    Handling Exceptions in Vector Operations

  79. 79Working with Linked Lists4 modules · 6 lessons

    Introduction to Linked Lists

    Searching in Linked Lists

    Modifying Linked Lists

    Choosing Between Vectors and Linked Lists

  80. 80Using Maps for Efficient Lookup2 modules · 5 lessons

    Introduction to Maps

    Lookup Operations with Maps

  81. 81Using Unordered Maps for Efficient Lookup2 modules · 5 lessons

    Introduction to Unordered Maps

    Customizing Unordered Maps

  82. 82Standard Library Containers Overview2 modules · 5 lessons

    Container Types and Characteristics

    Choosing the Right Container

  83. 83STL Container Best Practices3 modules · 9 lessons

    Choosing the Right Container

    Container Operations and Performance

    Associative Containers and Hash Functions

  84. 84Using Containers with Algorithms1 modules · 3 lessons

    Introduction to Containers and Algorithms

  85. 85Working with Iterators4 modules · 9 lessons

    Introduction to Iterators

    Generic Programming with Iterators

    Finding Elements with Iterators

    Separation of Algorithms and Containers

  86. 86Understanding Iterator Types1 modules · 4 lessons

    Iterator Type Variation

  87. 87Working with Stream Iterators4 modules · 5 lessons

    Introduction to Stream Iterators

    Using Stream Iterators with Output Streams

    Using Stream Iterators with Input Streams

    Stream Iterators with Algorithms

  88. 88Using Predicates with Algorithms1 modules · 4 lessons

    Understanding Predicates

  89. 89Understanding Algorithms in C++3 modules · 6 lessons

    Algorithm Fundamentals

    Standard Library Algorithms

    Algorithm Characteristics and Limitations

  90. 90Simplifying Algorithm Applications to Containers1 modules · 4 lessons

    Understanding Container Algorithms

  91. 91Best Practices for Using STL Algorithms3 modules · 10 lessons

    Understanding STL Algorithm Fundamentals

    Using STL Algorithms Effectively

    Additional C++ Standard Library Components

  92. 92Understanding Type Functions in C++3 modules · 6 lessons

    Type Functions Overview

    Key Type Functions

    Function Objects

  93. 93Utility Components in C++1 modules · 2 lessons

    Understanding Utility Components

  94. 94Resource Management Utilities1 modules · 3 lessons

    Understanding Resources

  95. 95Smart Pointers for Resource Management1 modules · 6 lessons

    Understanding Smart Pointers

  96. 96Understanding Specialized Containers in C++4 modules · 7 lessons

    Introduction to Specialized Containers

    Types of Specialized Containers

    Characteristics of Specialized Containers

    Design Trade-offs in Specialized Containers

  97. 97Working with Fixed-Size Sequences using array2 modules · 7 lessons

    Defining and Initializing array

    Using array with C-Style Functions and Comparing with Other Containers

  98. 98Working with Bitsets5 modules · 6 lessons

    Introduction to Bitsets

    Initializing Bitsets

    Bitset Operations

    Converting Bitsets

    Outputting Bitsets

  99. 99Working with Pairs and Tuples2 modules · 6 lessons

    Understanding Pairs

    Working with Tuples

  100. 100Measuring Time in C++2 modules · 5 lessons

    Understanding Time Measurement

    Best Practices for Time Measurement

  101. 101Function Adaptors and Argument Binding1 modules · 3 lessons

    Understanding Function Adaptors

  102. 102Creating Function Objects with bind()4 modules · 7 lessons

    Introduction to bind()

    Using Placeholders with bind()

    Binding Overloaded Functions

    Working with bind() Return Types

  103. 103Function Adaptors and Objects2 modules · 6 lessons

    Using mem_fn() for Non-Member Function Calls

    Working with std::function

  104. 104Compile-Time Type Functions3 modules · 5 lessons

    Introduction to Type Functions

    Standard Library Type Functions

    Metaprogramming with Type Functions

  105. 105Understanding Iterator Traits and Tag Dispatch2 modules · 6 lessons

    Iterator Traits and Type Functions

    Tag Dispatch Technique

  106. 106Understanding Type Predicates in C++2 modules · 4 lessons

    Introduction to Type Predicates

    Best Practices for Type Predicates

  107. 107C++ Standard Library Best Practices3 modules · 9 lessons

    Resource Management Best Practices

    Standard Library Containers and Utilities

    Function Objects and Time Measurement

  108. 108Numeric Computation in C++1 modules · 3 lessons

    Introduction to Numeric Computation

  109. 109C++ Mathematical Functions Overview3 modules · 6 lessons

    Standard Mathematical Functions

    Error Handling in Mathematical Functions

    Additional Mathematical Functions

  110. 110Numerical Algorithms in C++3 modules · 6 lessons

    Introduction to Numerical Algorithms

    Accumulate Algorithm

    Other Numerical Algorithms

  111. 111Working with Complex Numbers in C++2 modules · 4 lessons

    Understanding the Complex Number Template

    Operations on Complex Numbers

  112. 112Generating Random Numbers3 modules · 7 lessons

    Random Number Generation Basics

    Using Random Number Generators

    Simplifying Random Number Generation

  113. 113Vector Arithmetic Operations2 modules · 5 lessons

    Introduction to valarray

    Operations on valarray

  114. 114Understanding Numeric Limits in C++1 modules · 3 lessons

    Numeric Limits and Their Properties

  115. 115Best Practices for Numerical Computations2 modules · 11 lessons

    Numerical Computation Guidelines

    Introduction to Concurrency

  116. 116Concurrency Fundamentals1 modules · 3 lessons

    Introduction to Concurrency

  117. 117Concurrent Programming with Tasks and Threads2 modules · 6 lessons

    Introduction to Tasks and Threads

    Best Practices for Concurrent Programming

  118. 118Passing Data to Concurrent Tasks1 modules · 4 lessons

    Passing Arguments to Threads

  119. 119Returning Results from Tasks1 modules · 4 lessons

    Returning Results Techniques

  120. 120Synchronizing Access to Shared Data3 modules · 7 lessons

    Mutexes and Locks

    Avoiding Deadlocks

    Sharing Data vs Copying

  121. 121Waiting for External Events in Multithreading2 modules · 4 lessons

    Waiting for Time to Pass

    Using Condition Variables to Wait for Events

  122. 122Task Communication in C++1 modules · 4 lessons

    Task Communication Fundamentals

  123. 123Transferring Values between Tasks1 modules · 5 lessons

    Understanding Futures and Promises

  124. 124Using packaged_task for Concurrent Computations2 modules · 6 lessons

    Introduction to packaged_task

    Task-Based Parallelism with packaged_task

  125. 125Asynchronous Task Execution with async()2 modules · 5 lessons

    Introduction to async()

    Understanding async() Limitations and Use Cases

  126. 126Concurrency Best Practices and Guidelines3 modules · 9 lessons

    Concurrency Fundamentals

    Thread and Mutex Management

    Task-Based Programming

  127. 127The Origins of C++1 modules · 4 lessons

    C++ History and Design

  128. 128C++ Evolution and Standardization1 modules · 4 lessons

    C++ Development History

  129. 129The Origins and Early Development of C++3 modules · 9 lessons

    Design Goals and Initial Development

    Evolution and Key Features

    C++ Name Origin and Influences

  130. 130Understanding Virtual Functions in C++1 modules · 3 lessons

    How Virtual Functions Work

  131. 131Overriding Virtual Functions1 modules · 3 lessons

    Understanding Explicit Function Overriding

  132. 132Evolution of C++ Standards2 modules · 6 lessons

    History of C++ Standardization

    C++11 Standard and Features

  133. 133C++11 Extensions and Improvements1 modules · 1 lessons

    Overview of C++11 Extensions

  134. 134C++11 Language Features3 modules · 10 lessons

    Initialization and Type Deduction

    Control Flow and Constants

    Other Notable Features

  135. 135C++11 Standard Library Enhancements2 modules · 7 lessons

    New Components in C++11 Standard Library

    Improvements to Existing Components

  136. 136Understanding Deprecated Features in C++2 modules · 6 lessons

    Deprecated Features Overview

    Specific Deprecated Features

  137. 137Type Casting in C++3 modules · 7 lessons

    Named Casts

    Best Practices for Type Casting

    Hexadecimal Integers

  138. 138C++ and C Compatibility1 modules · 2 lessons

    Understanding C++ and C Compatibility

  139. 139C and C++: Understanding their Relationship2 modules · 6 lessons

    Relationship Between C and C++

    Incompatibilities Between C and C++

  140. 140C and C++ Compatibility Issues1 modules · 6 lessons

    Common Issues When Converting C Code to C++

Start C++ Programming Essentials today.

Listed at ₹8,999. Free for you right now.

C++ Programming Essentials

Course enrolled

C++ Programming Essentials

  • 758lessons & quizzes
  • 140chapters
  • 77hestimated
  • 0%progress

Finish every lesson and quiz to complete the course.

Start first lesson →