Re: Solving the data inheritance problem

From:

"Ondra Holub" <ondra.holub@post.cz>

Newsgroups:

comp.lang.c++.moderated

Date:

5 Dec 2006 11:28:59 -0500

Message-ID:

<1165322403.419420.183430@f1g2000cwa.googlegroups.com>

Kaba napsal:

Hello, I'd like to discuss about solutions to the following general
problem:

Given is an abstract class A (that is, contains at least one virtual
function). The derived classes of A are called B[i] (indexed by i).

The main purpose of inheritance is interface inheritance: this is to say
that all B[i] have commonly describable behaviour.

Now assume that the B[i] also have data in common: every B[i] will
contain the same block of data which is accessed using a fixed set of
functions.

If I now make the data handling functions virtual functions of A, I will
end up implementing identical boiler-plate code for each B[i]
implementation. This naturally raises objection: code replication should
be avoided.

The question now is: how do you model common data between B[i] without
replicating code?

A straightforward solution is the following: place the data in A and
implement the (non-virtual) handling functions there. I call this data
inheritance. This solution has the following draw-back:
Consider any function of B[i] that has to modify all of the data.
Examples include the assignment operator, the ubiquituous swap-function,
and constructors. The problem is that you have to remember to take care
of the parent data also! For example, in the B[i] assignment operator, B
[i] must call the assignment operator of A. Same applies to swap. The
problem is: what can be forgotten, will be forgotten.

It should'n be that the solution places this kind of burden on the
implementor of B[i].

Any ideas for better solutions?

--
Kalle Rutanen
http://kaba.hilvi.org

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

class A
{
public:
     // constructors are implemented elsewhere - not important for this
example
     A();
     A(const A& src);
};

template<typename T>
class B: public A
{
public:
     B(): A() { }
     B(const T& data): A(src), data_(data) { }

     T& GetData() { return data_; }
     const T& GetData() const { return data_; }

     void SetData(const T& data)
     {
         data_ = data;
     }

private:
     T data_;
};

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]