Modern C++ Essentials

This module covers the foundational building blocks of C++—variables, constants, data types, and operators. Learners will explore how to store and manipulate data effectively.

• Declare and initialize variables and constants
• Use built-in data types (int, float, char, bool, etc.)
• Perform type casting and conversions
• Apply arithmetic, logical, relational, and bitwise operators
• Understand operator precedence and associativity

Learners will explore decision-making and looping constructs to control the flow of their programs. This module emphasizes writing interactive and responsive code.

• Implement conditional logic using if, else if, and switch
• Use loops (for, while, do-while) for iteration
• Control execution flow with break, continue, and goto
• Build menu-driven and decision-based programs

Functions are introduced as a way to modularize code. Learners will define, call, and manage functions with parameters and return values, including recursive logic.

• Define and invoke functions with proper syntax
• Pass arguments by value and return results
• Use inline functions for performance optimization
• Apply recursion to solve problems (e.g., factorial, Fibonacci)
• Organize code for readability and reuse

This module dives into storing and manipulating collections of data. Learners will work with arrays and strings to handle structured input and output.

• Declare and manipulate 1D and 2D arrays
• Access and modify array elements using loops
• Handle character arrays and perform string operations
• Use built-in string functions (strlen, strcpy, strcmp, etc.)
• Solve problems involving lists, tables, and text processing

Pointers are introduced to help learners understand memory management and advanced data handling. This module builds a strong foundation for dynamic programming.

• Understand memory addresses and pointer variables
• Use pointers with arrays and functions
• Perform pointer arithmetic (*, &, ++, --)
• Explore dynamic memory concepts (intro to new and delete)
• Debug pointer-related issues like segmentation faults

Learners will explore user-defined data types to group related information. This module emphasizes organizing complex data and comparing memory usage.

• Define and use structures to group related data
• Access structure members using dot notation
• Create arrays of structures for tabular data
• Compare structures and unions for memory efficiency
• Apply structures in real-world scenarios (e.g., student records)

Learners dive into the core principles of object-oriented programming (OOP) in C++. This module introduces classes, objects, access control, and lifecycle management through constructors and destructors.

• Define and instantiate classes and objects
• Use access specifiers (public, private, protected) to control data visibility
• Implement constructors for object initialization
• Use destructors for resource cleanup and memory management

This module explores how C++ enables code reuse and hierarchy through inheritance. Learners will understand different inheritance types and how constructors behave in derived classes.

• Implement single, multiple, multilevel, and hierarchical inheritance
• Override constructors in derived classes
• Control member access across base and derived classes using access specifiers
• Understand base class initialization and constructor chaining

Learners will explore compile-time and runtime polymorphism, enabling flexible and dynamic behavior in programs. This module covers function overloading, overriding, and virtual functions.

• Implement function overloading for multiple behaviors with the same name
• Override base class functions in derived classes
• Use virtual functions to enable runtime polymorphism
• Understand vtables and dynamic dispatch mechanisms

• Overload arithmetic operators (+, -, *, /) for custom classes
• Implement unary and binary operator overloading
• Understand operator function syntax and return types
• Apply operator overloading in practical scenarios (e.g., complex numbers, vectors)

Learners will explore generic programming using templates. This module enables writing flexible and reusable code for functions and classes.

• Create function templates for type-independent operations
• Define class templates to handle generic data structures
• Understand template instantiation and type deduction
• Apply templates in sorting, searching, and container design

This module introduces robust error handling using C++ exceptions. Learners will write safe code that gracefully handles runtime errors.

Use try, catch, and throw blocks to manage exceptions

Handle multiple exception types and nested exceptions

Create custom exception classes

Improve program stability and user feedback during errors

Learners consolidate their understanding by building a project that applies OOP principles. This module includes presentation, peer review, and instructor feedback.

• Design and implement a console-based project using classes, inheritance, and polymorphism
• Apply templates and exception handling in real-world scenarios
• Demonstrate modular design, code reuse, and abstraction
• Present project logic and receive constructive evaluation