Professional C++ 17: Object‑Oriented Programming

Explore first classes in a C++17 object-oriented course, design class specs with Google Test, and implement an RGB color class with static and const members.

Implement the rgb color class in a test-driven workflow, packing red, green, and blue into a 24-bit value with set and get, and define static colors.

Explore constructors in C++ and how to initialize objects with default, parameterized, and copy constructors, including constructor chaining, initialization lists, destructors, and rectangle class implementation.

Review pointers and references in C++17, covering null and uninitialized pointers, memory management with new and delete, and safe use of const, references, and pass-by-reference parameters.

Streamline C++ code by switching object parameter passing from value to reference with const correctness, and implement a landscape class that stores 20 circle pointers and tracks size.

The big five govern resource management in C++ objects, detailing copy and move constructors, assignment operators, and destructors to prevent memory errors from shallow copies and enable deep copies.

Explore the big five in C++ with a landscape class that uses a pointer. Learn to implement a destructor, a deep copy, and move and assignment operators to avoid leaks.

Learn how to use try, catch, and throw to manage exceptions and how invariants and RAII prevent leaks, ensuring safe error handling in C++.

Apply test-driven development to validate parameter ranges in c++ 17, throwing invalid argument for rgb, circle, and rectangle tests, with exceptions caught by reference for robust error handling.

Operator overloading lets you redefine operators for classes to improve readability and enable implicit or explicit conversion operators; implement as member or global functions and choose intuitive operators.

Explore templates in C++, learning how they enable generic programming with class and function templates. Master type and value parameters, header-file placement, overloads, and type deduction.

Explore variadic templates in C++ by using ellipsis to pass a variable number of arguments, and learn compile-time overload generation with show and vector examples.

Master variadic templates by expanding a show function to accept multiple arguments using template packs and recursive-like calls, and migrate landscape code from arrays of circle pointers to a vector.

Implement and switch to unique pointers to own circles within landscape, fix count tests, and apply the big five via copy constructors and destructors, ensuring safe memory management.

Explore shared pointers and reference counting, contrasting them with unique pointers, demonstrating use count behavior with copies, and applying make_shared in code while noting design implications for a landscape object.

Learn to use shared pointers in C++17 by converting circle objects to shared pointers and updating tests and functions. See how shared pointers simplify ownership and keep vector copies lightweight.

Explore how weak pointers provide non-owning references from shared pointers, how locking yields a strong pointer, and how ownership decisions shape object lifetimes.

Learn inheritance and polymorphism in C++17, including base and derived classes, virtual and override keywords, and how substitutability enables runtime polymorphism with pet, cat, and dog examples.

Develop a base shape class shared by circle and rectangle, refactor with smart pointers, and make landscape depend on shape rather than a specific class, using covariance and overrides.

Explore how base constructors run before derived ones in C++ inheritance, why destruction must be polymorphic with virtual destructors, and patterns like factory methods and inheriting constructors in modern C++.

Learn functional programming in C++ with callbacks, inversion of control, function pointers, and lambda expressions, moving boilerplate flow into a library and implementing a console menu framework.

Set up a C++17 project in Visual Studio or VS Code, avoiding duplicate main from Google Test, and build a menu system with Menu class using initializer_list and variadic templates.

Explore the command design pattern in C++ 17 by implementing a command interface, concrete show and quit commands, and replacing switch statements with polymorphic callbacks to achieve inversion of control.

Replace the switch-case with callback objects to configure the framework, turning the app into a configurator, while a functor uses operator() to define a function object with no data members.

Explore how to design functors in C++ by converting a class method into the function call operator, enabling objects to act like functions and simplifying command-like patterns.

Explore lambda expressions in C++11 as a simple anonymous function and adapter pattern alternative to defining a function object, with capture by value or reference and optional return type.

Learn to use lambda expressions with templates and the functional header for flexible menu callbacks. Capture outer scope, support function pointers, functors, and demonstrate inversion of control in your app.

Explore the C++ standard library algorithms and numeric operations, using lambda-based foreach, transform, and partition to manipulate containers. Learn accumulate, set operations, inner product, and iota for data processing.

Explore C++17 utilities such as initialize list, tuples, pair, optional, and date-time with chrono, and use clocks and user defined literals for precise duration measurements.