Implementing Inheritance in C++ for Clean Code

Introduction

Welcome to another lesson of the Clean Code in C++ course! In this course, we have explored foundational concepts like the Single Responsibility Principle, encapsulation, and constructors, all essential for writing clear, maintainable, and efficient code. In this lesson, we'll focus on implementing inheritance wisely. By understanding the role of inheritance, we'll learn how to apply it effectively to enhance code readability and organization while maintaining the principles of clean code.

How Inheritance is Important to Writing Clean Code

Inheritance is a powerful feature in object-oriented programming that allows for code reuse and logical organization. It enables developers to create a new class based on an existing class, inheriting its properties and behaviors. This can lead to more streamlined and easier-to-understand code when used appropriately. Code Reuse and Reduction of Redundancies : By creating subclasses that inherit from a base class, you can avoid duplicating code, making it easier to maintain and extend. Improved Readability : Logical inheritance hierarchies can improve the clarity of your software. For example, if you have a base class Vehicle, with subclasses Car and Motorcycle, the organization makes intuitive sense and clarifies each class's role. Alignment with Previous Concepts : Inheritance should respect the Single Responsibility Principle and encapsulation. Each class should have a clear purpose and keep its data protected, whether it's a base class or a subclass.

Best Practices When Using Inheritance

To leverage inheritance effectively, it's important to follow several best practices: Favor Composition Over Inheritance : Sometimes, inheritance can lead to tightly coupled code. In such cases, composition (where you include instances of other classes) might be a better option. Clear and Stable Base Class Interfaces : Provide a consistent and limited interface in base classes to prevent subclasses from depending too much on implementation details. Avoid Deep Inheritance Hierarchies : Deep hierarchies can complicate the understanding and maintenance of the code, leading to harder debugging and modification. Common pitfalls include overusing inheritance to model relationships that might not naturally fit an "is-a" relationship and abusing inheritance for code sharing without considering logical organization.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

C++

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    void work() {
        std::cout << "Person working" << std::endl;
    }
};

class Employee : public Person {
public:
    std::string employeeId;

    void fileTaxes() {
        std::cout << "Employee filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    void holdMeeting() {
        std::cout << "Manager holding a meeting" << std::endl;
    }
};

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    void work() {
        std::cout << "Person working" << std::endl;
    }
};

class Employee : public Person {
public:
    std::string employeeId;

    void fileTaxes() {
        std::cout << "Employee filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    void holdMeeting() {
        std::cout << "Manager holding a meeting" << std::endl;
    }
};

C++

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    Person(const std::string& name, int age) : name(name), age(age) {}
};

class Employee {
public:
    Person personDetails;
    std::string employeeId;

    Employee(const Person& personDetails, const std::string& employeeId)
        : personDetails(personDetails), employeeId(employeeId) {}

    void fileTaxes() {
        std::cout << personDetails.name << " filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    Manager(const Person& personDetails, const std::string& employeeId)
        : Employee(personDetails, employeeId) {}

    void holdMeeting() {
        std::cout << personDetails.name << " holding a meeting" << std::endl;
    }
};

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    Person(const std::string& name, int age) : name(name), age(age) {}
};

class Employee {
public:
    Person personDetails;
    std::string employeeId;

    Employee(const Person& personDetails, const std::string& employeeId)
        : personDetails(personDetails), employeeId(employeeId) {}

    void fileTaxes() {
        std::cout << personDetails.name << " filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    Manager(const Person& personDetails, const std::string& employeeId)
        : Employee(personDetails, employeeId) {}

    void holdMeeting() {
        std::cout << personDetails.name << " holding a meeting" << std::endl;
    }
};

C++

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    void work() {
        std::cout << "Person working" << std::endl;
    }
};

class Employee : public Person {
public:
    std::string employeeId;

    void fileTaxes() {
        std::cout << "Employee filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    void holdMeeting() {
        std::cout << "Manager holding a meeting" << std::endl;
    }
};

C++

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    Person(const std::string& name, int age) : name(name), age(age) {}
};

class Employee {
public:
    Person personDetails;
    std::string employeeId;

    Employee(const Person& personDetails, const std::string& employeeId)
        : personDetails(personDetails), employeeId(employeeId) {}

    void fileTaxes() {
        std::cout << personDetails.name << " filing taxes" << std::endl;
    }
};

class Manager : public Employee {
public:
    Manager(const Person& personDetails, const std::string& employeeId)
        : Employee(personDetails, employeeId) {}

    void holdMeeting() {
        std::cout << personDetails.name << " holding a meeting" << std::endl;
    }
};

Introduction

How Inheritance is Important to Writing Clean Code

Best Practices When Using Inheritance

Join the 1M+ learners on CodeSignal

Bad Example

Refactored Example

Summary and Next Steps