C++ Class Design/ Excluding Base Class members - c++

Question

Assuming I just created a class named Base with 2 or 3 Members, that's about this:
class Base
{
private:
std::string name;
std::string number;
public:
virtual std::string get() const;
virtual void set();
//...
};
And in the next step I want to create a few derived classes form this class. But in some of the derived classes I don't need all members of the Base class.
How can I exclude some members of Base-class in a derived class and keep the others?
For Instance in:
class Derived_One : public Base {
private:
std::string wight;
int A;
public:
//...
};
I want to keep only the first attribute of the Base Class (std::string name) and remove the second attribute which is std::string number. How can I exclude it in the derived class Drive_One?
I am looking for an elegant solution for this change or a widely known Design Pattern which I do not know yet.

Answer 1

If your derived class only needs some of the base class, it is a sign that the base class should be split into two. Either one class derived from the other or two separate classes.
An example of the first case could be something like this:
class Base_One
{
private:
std::string name;
public:
//...
};
class Base_Two : public Base_One
{
private:
std::string number;
public:
//...
};
class Derived_One : public Base_One
{
private:
std::string wight;
int A;
public:
//...
};
class Derived_Two : public Base_Two
...
In the second case (if it does not make sense for Base_Two to derive from Base_One), Base_One and Base_Two would be separate classes and derived classes would derive from one or both of them, i.e. the example above would be modified as follows:
class Base_Two
{
private:
std::string number;
public:
//...
};
...
class Derived_Two : public Base_One, public Base_Two
...

Answer 2

derived classes I don't need all members of the Base class.
Which simply says: This is not a common base class!
Whats to do:
Option 1)
Split base class to several ones and create a linear hierarchy structure.
But this may come to a point, where your design would be to complex, especially if it feels natural to cross call from different members of different classes in the hierarchy.
Option 2)
If your design becomes more complex by simply splitting to linear hierarchy, you should give CRTP a chance.
This enables to inject special functionality into a class hierarchy and keeps the design cleaner. The bad side is, that this may lead to a lot of template instances which waste memory. You have a more maintainable design but you may pay with higher memory consumption.
What is the best for your design can't be answered on the fly from some lines of code. Simply try to understand both options and take a decision. Maybe you will change it later.