Single Responsibility Principle in C++: SOLID as a Rock

This article is the first part of a five-part series about SOLID as
Rock design principle series. The SOLID design principles focus on
developing software that is easy to maintainable, reusable &
extendable. In this article, we will see an example of the Single Responsibility Principle in C++ along with its benefits & generic guideline.

/!\: Originally published @ www.vishalchovatiya.com.

By the way, If you haven't gone through my previous articles on design principles, then below is the quick links:

Intent

A class should have only one reason to change

In other words, SRP states that classes should be cohesive to the
point that it has a single responsibility, where responsibility defines
as "a reason for the change."

Motivation: Violating the Single Responsibility Principle

class Journal {
    string          m_title;
    vector<string>  m_entries;

public:
    explicit Journal(const string &title) : m_title{title} {}
    void add_entries(const string &entry) {
        static uint32_t count = 1;
        m_entries.push_back(to_string(count++) + ": " + entry);
    }
    auto get_entries() const { return m_entries; }
    void save(const string &filename) {
        ofstream ofs(filename); 
        for (auto &s : m_entries) ofs << s << endl;
    }
};

int  main() {
    Journal journal{"Dear XYZ"};
    journal.add_entries("I ate a bug");
    journal.add_entries("I cried today");
    journal.save("diary.txt");
    return EXIT_SUCCESS;
}

Above C++ example seems fine as long as you have a single domain object i.e. Journal. but this is not usually the case in a real-world application.
As we start adding domain objects like Book, File, etc. you have to implement save method for everyone separately which is not the actual problem.
The real problem arises when you have to change or maintain save
functionality. For instance, some other day you will no longer save
data on files & adopted database. In this case, you have to go
through every domain object implementation & need to change code all over which is not good.
Here, we have violated the Single Responsibility Principle by providing Journal class two reason to change i.e. i. Things related to Journal, ii. Saving the Journal
Moreover, code will also become repetitive, bloated & hard to maintain.

Solution: Single Responsibility Principle Example in C++

As a solution what we do is a separation of concerns.

class Journal {
    string          m_title;
    vector<string>  m_entries;

public:
    explicit Journal(const string &title) : m_title{title} {} 
    void add_entries(const string &entry) {
        static uint32_t count = 1;
        m_entries.push_back(to_string(count++) + ": " + entry);
    } 
    auto get_entries() const { return m_entries; }
    //void save(const string &filename)
    //{
    //    ofstream ofs(filename); 
    //    for (auto &s : m_entries) ofs << s << endl;
    //}
};

struct SavingManager {
    static void save(const Journal &j, const string &filename) {
        ofstream ofs(filename);
        for (auto &s : j.get_entries())
            ofs << s << endl;
    }
};

SavingManager::save(journal, "diary.txt");

Journal should only take care of entries & things related to the journal.
And there should be one separate central location or entity which does the work of saving. In our case, its SavingManager.
As your SavingManager grows, you have all the saving related code will be at one place. You can also templatize it to accept more domain objects.

Benefits of Single Responsibility Principle

=> Expressiveness

When the class only does one thing, its interface usually has a
small number of methods which is more expressive. Hence, It also has a
small number of data members.
This improves your development speed & makes your life as a software developer a lot easier.

=> Maintainability

We all know that requirements change over time & so does the
design/architecture. The more responsibilities your class has, the more
often you need to change it. If your class implements multiple
responsibilities, they are no longer independent of each other.
Isolated changes reduce the breaking of other unrelated areas of the software.
As programming errors are inversely proportional to complexity,
being easier to understand makes the code less prone to bugs &
easier to maintain.

=> Reusability

If a class has multiple responsibilities and only one of those needs
in another area of the software, then the other unnecessary
responsibilities hinder reusability.
Having a single responsibility means the class should be reusable without or less modification.

Yardstick to Craft SRP Friendly Software in C++

SRP is a double-edged sword. Be too specific & you will end up
having hundreds of ridiculously interconnected classes, that could
easily be one.
You should not use SOLID principles when you feel you are
over-engineering. If you boil down the Single Responsibility Principle,
the generic idea would be like this:

The SRP is about limiting the impact of change. So, gather together the things that change for the same reasons. Separate those things that change for different reasons.

Adding more to this, If your class constructor has more than 5-6 parameters then it means either you are not followed SRP or you are not aware of builder design pattern.

Conclusion

The SRP is a widely quoted justification for refactoring. This is
often done without a full understanding of the point of the SRP and its
context, leading to fragmentation of codebases with a range of negative
consequences. Instead of being a one-way street to minimally sized
classes, the SRP is actually proposing a balance point between
aggregation and division.

Have Any Suggestions, Query or Wants to Say Hi? Take the Pressure Off, You Are Just a Click Away.🖱️