how to avoid attribute's redundancy coming from a inheritance - c++

Question

say I have this example :
class A1
{
private:
string name;
}
class A
{
private:
A1* field;
}
class B1 : public A1
{
private:
int id;
}
class B : public A
{
private:
B1* field;
}
so in this case I would have in my B class:
id attribute from the B1 class
name attribute coming from the inheritance of the class A.
another name attribute coming form the inheritance of B1 class from the class A1.
So what should I do to avoid this redundancy ?

Answer 1

I don't see any redundancy here. Let's rename the classes into something more useful:
class Animal // A1
{
private:
string name;
}
class Person // A
{
private:
Animal* housePet;
}
class Dog : public Animal // B1
{
private:
int breedId;
}
class DogTrainer : public Person // B
{
private:
Dog* trainee;
}
You see, no field can be safely eliminated. The trainee is not the same as the housePet, each of them needs a separate name.

Answer 2

No, you haven't any redundancy.
B class didn't inherit any member from its base classes because they have been declared as private (then visible and accessible only from within the class they are declared).
For example:
class A
{
private:
int _privateMember;
protected:
int _protectedMember;
public:
int _publicMember;
};
class B : public A
{
void test()
{
// This doesn't work, this field is private to the class
// where it has been declared (A)
_privateMember = 1;
// This works, a protected member is accessible inside the class
// where it's declared and derived classes.
_protectedMember = 1;
// This works, a public member is always visible and accessible.
_publicMember = 1;
}
};
void test()
{
A a;
// This doesn't work, a private field isn't accessible outside the class
// where it has been declared
a._privateMember = 1;
// This doesn't work, a protected member is accessible only inside the class
// where it has been declared and its derived classes
a._protectedMember = 1;
// This works, a public member is always visible.
a._publicMember = 1;
}
Things can be more complicated than this, you do not need to always use public inheritance, for example:
class C : protected A
{
};
void test()
{
C c;
// This doesn't work! Field is public for its class but C has inherited from A
// in a protected way (so only derived classes know that it derives from A).
c._publicMember = 1;
}
Moreover you can make all private members of a class visible to another class or function using the friend declaration:
class D
{
private:
int _privateMember;
public:
int _publicMember;
friend class DFriend;
};
class DFriend
{
void test()
{
D d;
// This works, public members are accessible
d._publicMember = 1;
// This works too, this class is a friend of D
d._privateMember = 1;
}
};
That said remember that when you derive from a base class you say "derived class is of type base class". For example you have a base class to describe a planet with some properties (modeled for simplicity as public fields):
class Planet
{
public:
int Diameter;
};
Then suddenly you discover you have to make it more general and you add a more general base class called CelestialBody:
class CelestialBody
{
public:
bool canCapture(CelestialBody anotherBody)
{
// Some calculations
}
private:
vector<CelestialBody> _capturedBodies;
};
class Planet : public CelestialBody
{
public:
int Diameter;
};
Now you say this:
A celestial body is something that can capture another celestial body;
A celestial body keeps a private list of captured bodies because they may change some of its properties.
A planet is a celestial body.
A planet has a public (integer) property to describe its diameter in Km.
Private members of CelestialBody aren't visible outside of it (kind of implementation details). World knows that a Planet is a CelestialBody (because of public inheritance) then everything was public in CelestialBody is public in Planet too.
If you do not want to say this then you shouldn't simply use inheritance. Take a look to this articles:
Composition and inheritance: when to inherit from another object and when to include another object as field.
Incapsulation: incapsulation of informations inside a class.