Is there a difference between Getters and Setters inside a public base class and inside the derived class?

Hello fellow programmers,

I have a fairly simple question. Does anyone know if there is any difference between me putting the get and set functions inside the public part of the base class and inside the public part of one of the derived classes? Basically i want the derived class to access the protected variable of the base class and i want to know if there is a difference between the Type1 and Type 2 codeblocks that i wrote.

Thanks a lot in advance to anyone who answers.

//Type1
#include <iostream>
using namespace std;

class base
{
    public:
    string getS1()
    {
        return s1;
    }
    void setS1(string s)
    {
        s1 = s;
    }

    protected:
    string s1;
};

class derived: public base
{
    public:
    string NotUsed;
};

int main()
{
    derived d;
    d.setS1("Test");
    cout << d.getS1() << endl;
}

//Type2
#include <iostream>
using namespace std;

class base
{
    public:

    protected:
    string s1;
};

class derived: public base
{
    public:
    string getS1()
    {
        return s1;
    }
    void setS1(string s)
    {
        s1 = s;
    }
    
    string NotUsed;
};

int main()
{
    derived d;
    d.setS1("Test");
    cout << d.getS1() << endl;
}

I have tried both of the codeblocks above and i got the same results. I just want to know if there is any difference between these 2 implementations.

It's usually better to keep your setters and getters for base class members in the base class.
Imagine the instance where you only need a Base object (and your members are private). There isn't a way for you to access those members.
And if you place the setters in the base class, you can always access them from any derived class, and the base class as well!

The main difference between the implementations is how they handle encapsulation and design. In Type1, the getter and setter functions are placed in the base class and have public access. This means that all derived classes will inherit these functions. This approach can be helpful if you want the base class to be responsible for providing a consistent interface for interaction. It aligns with the principle of encapsulation, where the base class manages access to its internal state.

On the other hand, using Type2 could lead to code that is less organized and harder to maintain. This is because you would need to manually redefine the getter and setter functions in each derived class.

Therefore, using Type1 is generally preferred as it promotes code reuse and maintains a clear separation of concerns. It allows for a consistent interface across derived classes and avoids duplication of code.