Re: Best design for my classes to avoid code duplication?
On 2010-01-08, Jef Driesen <jefdriesen@hotmail.com.invalid> wrote:
Hi,
I have the following problem. I have an interface (abstract base class)
to represent a "device":
class IDevice {
virtual Read () = 0;
}
I have a number of concrete devices, that implement this interface. The
typical implementation of a device consist of a protocol part (defines
how to read the data) and a layout part (defines the structure of the
data and thus where to read the data):
class Device : IDevice {
m_protocol;
m_layout;
...
}
Device::Device ()
: m_protocol (...), m_layout (...)
{
...
}
Device::Read ()
{
return m_protocol->Read (m_layout->offset);
}
But now I want to implement some devices which are very similar. For
instance two devices sharing the same layout, but using a different
protocol. What is the preferred way to implement this, without
duplicating all code?
Use aggregation for the protocol and layout rather than composition.
It almost looks like your Device class is just an empty facade that
delegates its operations to the m_protocol and m_layout that it
contains.
These members can just be references (to base classes which have
virtual functions).
The IDevice interface binds to Device, which proxies all of the calls to
these other objects. A Device instance can appear to be of effectively
different types because it can have references to different types of
protocols and layouts.
Basically, only the constructor is different. All other member functions
(such as Read) have exactly the same implementation.
ADevice::ADevice ()
: m_protocol (new AProtocol (...)), m_layout (new Layout (...))
{
...
}
BDevice::BDevice ()
: m_protocol (new BProtocol (...)), m_layout (new Layout (...))
{
...
}
So they already are pointers? You are one step away:
Device::Device(ProtocolBase *proto, LayoutBase *layout)
: m_protocol(proto)
, m_layout(layout)
{
}
Now it's up to whoever is constructing this object to configure it
with an appropriate combination of protocol and layout.
This is where the class factory pattern comes in handy.
// derives from IDeviceFactory
// makes devices configured with AProtocol and ALayout
static ADeviceFactory adf;
// factoryPtr points to some IDeviceFactory implementation;
// just call the Create virtual function to make a factory of
// its kind.
Device *dev = factoryPtr->Create();