Redundant private member data replication in implementation hierarchy - c++

Question

My question concerns the combination of public and private inheritance as a tool to separate interface and implementation in a C++ class. In this pattern, the interface base class declares the common functions (class Base0). The common implementation is carried out in a class derived virtually from the interface base (class Impl0 : virtual public Base0). This class contains any common data members. The extension classes are written in two steps. First the extended interface is defined by virtual inheritance from the interface base (class Base1 : virtual public Base0). Second, the extended implementation is carried out by deriving publicly from Base1 (for interface) and privately from Impl0 (for implementation): class Impl1 : public virtual Base1, private Impl0. My questions are the following:
(1) if the functions in the extension class define functions that require common data in Impl0, do I have to replicate that data in `Impl1'?
(2) Is there any way to avoid this replication?
As a minimal example, consider a class hierarchy for implementing the four basic arithmetic functions: add(), substr(), mult() and div(). The basic version, MathOps, contains the add() and subtr() functions. The extended version, MathOps_Extn, contains mult() and div(). The above technique gives the following class hierarchy.
#include<iostream>
using std::cout;
using std::endl;
class MathOps {
public:
virtual int add(int x) = 0;
virtual int subtr(int x) = 0;
};
class MathOps_Impl : public virtual MathOps {
private:
int m_y;
public:
MathOps_Impl(int y) : m_y(y) {
cout << "MathOps_Impl initialized with value: " << m_y << endl;
}
virtual int add(int x) { return x + m_y;}
virtual int subtr (int x) { return m_y - x;}
};
class MathOps_Extn : public virtual MathOps {
// Extends MathOps by adding mult() and div()
public:
virtual int mult(int x) = 0;
virtual int div(int x) = 0;
};
class MathOps_Extn_Impl : public virtual MathOps_Extn, private MathOps_Impl {
private:
int m_y; // Have to replicate member data m_y here.
public:
MathOps_Extn_Impl(int y) : MathOps_Impl(y), m_y(y) {
cout << "MathOps_Extn_Impl initialized with value: " << m_y << endl;
}
virtual int mult(int x) {
return x * m_y;
}
virtual int div(int x) {
int quotient = x == 0? 0 : m_y/x;
return quotient;
}
};
int main() {
MathOps_Extn* B = new MathOps_Extn_Impl(10);
cout << "add 20: " << B->add(20) << endl;
cout << "subtr 20: " << B->subtr(20) << endl;
cout << "mult 2: " << B->mult(2) << endl;
cout << "div 5: " << B->div(5) << endl;
Note the replication of m_y in MathOps_Extn_Impl. Is there any way to avoid this replication?

Answer 1

Note the replication of m_y in MathOps_Extn_Impl. Is there any way to
avoid this replication?
Yes. Give MathOps_Impl::m_y protected access instead of private.
You're explicitly asking why derived classes can't access private data. That's by design.

Answer 2

You can give access to the common data, without breaking encapsulation, via protected member functions in the common implementation class.
Gratuitous example follows :)
#include <cstdio>
class Math
{
public:
virtual ~Math() {}
virtual int add(int b) const = 0;
};
class MoreMath : public virtual Math
{
public:
virtual ~MoreMath() {}
virtual int subtract(int b) const = 0;
};
class MathImpl : public virtual Math
{
private:
int m_a;
public:
MathImpl(int a) : m_a(a) {}
virtual ~MathImpl() {}
int add(int b) const { return m_a + b; }
protected:
int value() const { return m_a; }
};
class MoreMathImpl : public virtual MoreMath, private MathImpl
{
public:
MoreMathImpl(int a) : MathImpl(a) {}
int subtract(int b) const { return value() - b; }
};
int main()
{
MoreMath* one = new MoreMathImpl(1);
printf("1 + 2 = %d\n", one->add(2));
printf("1 - 2 = %d\n", one->subtract(2));
delete one;
return 0;
}