**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in C++ **Topic:** Design a class-based system implementing inheritance and smart pointers.(Lab topic) **Table of Contents** 1. Introduction to Class-Based Systems 2. Designing a Class Hierarchy 3. Implementing Inheritance 4. Using Smart Pointers 5. Best Practices and Advanced Techniques 6. Example Use Case: A Simple Banking System 7. Conclusion and Further Reading **Introduction to Class-Based Systems** In object-oriented programming, a class-based system is a design paradigm that allows you to create a hierarchy of classes, with each class inheriting properties and behavior from its parent class. This approach promotes code reusability, modularity, and ease of maintenance. **Designing a Class Hierarchy** When designing a class hierarchy, consider the following principles: 1. **Single Responsibility Principle**: Each class should have a single responsibility and should not be responsible for multiple, unrelated tasks. 2. **Open/Closed Principle**: A class should be open for extension but closed for modification. 3. **Liskov Substitution Principle**: Derived classes should be substitutable for their base classes. To design a class hierarchy, identify the core classes and their relationships. Use inheritance to create a hierarchical structure, with each subclass inheriting properties and behavior from its parent class. **Implementing Inheritance** In C++, inheritance is implemented using the `:` keyword. For example: ```cpp class Animal { public: void sound() { std::cout << "Animal makes a sound" << std::endl; } }; class Dog : public Animal { public: void sound() { std::cout << "Dog barks" << std::endl; } }; ``` In this example, the `Dog` class inherits the `sound()` method from the `Animal` class. **Using Smart Pointers** Smart pointers are a crucial aspect of modern C++ programming. They provide automatic memory management, eliminating the risk of memory leaks and dangling pointers. In this example, we'll use `std::unique_ptr` to manage the lifetime of dynamically allocated objects: ```cpp class Animal { public: void sound() { std::cout << "Animal makes a sound" << std::endl; } }; class Dog : public Animal { public: void sound() { std::cout << "Dog barks" << std::endl; } }; int main() { std::unique_ptr<Animal> dog = std::make_unique<Dog>(); dog->sound(); return 0; } ``` In this example, the `std::unique_ptr` ensures that the `Dog` object is properly deleted when it goes out of scope. **Best Practices and Advanced Techniques** When using inheritance and smart pointers, consider the following best practices and advanced techniques: 1. **Use `std::unique_ptr` for exclusive ownership**: When a single class owns a dynamically allocated object, use `std::unique_ptr`. 2. **Use `std::shared_ptr` for shared ownership**: When multiple classes share ownership of a dynamically allocated object, use `std::shared_ptr`. 3. **Avoid raw pointers**: Raw pointers can lead to memory leaks and dangling pointers. Instead, use smart pointers. 4. **Use `std::make_unique` and `std::make_shared`**: These functions ensure that dynamically allocated objects are properly initialized and managed. **Example Use Case: A Simple Banking System** Here's an example use case that demonstrates a class-based system implementing inheritance and smart pointers: ```cpp class Account { public: virtual void deposit(double amount) = 0; virtual void withdraw(double amount) = 0; }; class SavingsAccount : public Account { public: void deposit(double amount) override { balance += amount; } void withdraw(double amount) override { balance -= amount; } private: double balance = 0.0; }; class CheckingAccount : public Account { public: void deposit(double amount) override { balance += amount; } void withdraw(double amount) override { balance -= amount; } private: double balance = 0.0; }; int main() { std::unique_ptr<Account> account = std::make_unique<SavingsAccount>(); account->deposit(100.0); account->withdraw(50.0); return 0; } ``` In this example, the `SavingsAccount` and `CheckingAccount` classes inherit the `Account` class, which defines the `deposit()` and `withdraw()` methods. The `std::unique_ptr` ensures that the `SavingsAccount` object is properly deleted when it goes out of scope. **Conclusion and Further Reading** In this topic, we've explored the concepts of class-based systems, inheritance, and smart pointers. We've also seen how to design a class hierarchy, implement inheritance, and use smart pointers to manage dynamically allocated objects. For further reading, I recommend the following resources: * **C++20 Standard**: The official C++20 standard provides a comprehensive guide to modern C++ programming. * **Effective Modern C++**: This book by Scott Meyers provides a detailed guide to modern C++ programming, including best practices and advanced techniques. * **C++11/C++14/C++17/C++20 Features**: This GitHub repository provides a comprehensive overview of modern C++ features. Do you have any questions or need further clarification on any of the topics covered in this course? Please leave a comment below, and I'll be happy to help!