How to share same data between multiple instances at inheritance levels? - c++

Question

I'd like to instance multiple object of the same inheritance levels, and for each of these level use the same data. So I think about inheritance and static members of a class.
This is my attempt:
#include <iostream>
class Father
{
public:
static int sValue;
inline int GetValue() { return sValue * 10; }
};
class Child1 : public Father
{
public:
};
class Child2 : public Father
{
public:
};
int Father::sValue = 0;
int main()
{
Child1 child1_1;
Child1 child1_2;
Child2 child2_1;
Child2 child2_2;
child1_1.sValue = 1;
child2_1.sValue = 2;
std::cout << child1_2.GetValue() << std::endl;
std::cout << child2_2.GetValue() << std::endl;
}
In my example both Child1 instances should return 10 with GetValue(), and both Child2 instances should return 20 using GetValue(). Since the function its the same, I don't want to override it for each child (that's why I placed it in Father).
The problem is that also Child1 instances returns 20 calling GetValue().
Thus static is shared across "main" parent, not child.
Since that sValue value is used into GetValue(), its correct to place it here. But I cannot separate static/same data so.
How would you do this?

Answer 1

splrs user has correctly identified your problem and the solution is correct. You need two different functions with two different static objects. You can avoid repeating the code, by using a template:
template<class Child>
struct Father {
static int sValue;
int GetValue() { /* ... */ }
};
struct Child1 : Father<Child1> {};
struct Child2 : Father<Child2> {};
This idiom is known as Curiously recurring template pattern.
Now of course, there is no common parent. If you need that, you can inherit the template from a non-template base:
struct FatherBase {};
template<class Child>
struct Father : FatherBase { /*...*/ };
And, if you need to access the different versions of GetValue from the base, then you need a virtual function:
struct FatherBase {
virtual int GetValue() = 0;
};
template<class Child>
struct Father : FatherBase {
// ...
int GetValue() override { /* ... */ }
};

Answer 2

You're modifying Father::sValue when you call child1_1.sValue = 1; and child2_1.sValue = 2; There's one instance, which belongs to Father, so however you access it (via a method against the classes or the instances) you'll get whatever it was set to prior to the call to GetValue().
If you want a Child1 and a Child2 version then add static members and methods to those classes.

Answer 3

I think the following can be what you're after:
class Father
{
public:
inline int GetValue() { return DoGetValue() * 10; }
void SetValue( int value ) { DoSetValue( value ); }
protected:
virtual int DoGetValue() = 0;
virtual void DoSetValue( int value ) = 0;
};
class Child1 : public Father
{
public:
static int sValue;
protected:
int DoGetValue() override { return sValue; }
void DoSetValue( int value ) override { sValue = value; }
};
class Child2 : public Father
{
public:
static int sValue;
protected:
int DoGetValue() override { return sValue; }
void DoSetValue( int value ) override { sValue = value; }
};
int Child1::sValue = 0;
int Child2::sValue = 0;
int main()
{
Child1 child1_1;
Child1 child1_2;
Child2 child2_1;
Child2 child2_2;
child1_1.SetValue( 1 );
child2_1.SetValue( 2 );
std::cout << child1_2.GetValue() << std::endl;
std::cout << child2_2.GetValue() << std::endl;
}