Re: Best design for my classes to avoid code duplication?
On Jan 9, 3:10 pm, "Balog Pal" <p...@lib.hu> wrote:
"Juha Nieminen" <nos...@thanks.invalid>
Jerry Coffin wrote:
From the looks of things, you could use a template:
Isn't that a bit of a far-fetched solution for something
which is exactly what inheritance was invented for?
far-fetched? The request mapped perfectly to what templates
do, and Jerry showed the code that gives the perfect solution
(to what was stated).
Inheritance was invented for a different thing, and would
solve this case in a contorted way if at all -- and OP seem to
be familiar with it enough, and turned here discovering the
redundancy it leaves.
I wouldn't say that inheritance was invented for this, but using
inheritance to provide "custom" initialization is a more or less
standard C++ idiom, and hardly what one would consider
contorted. (You might start by looking at something like
std::fstream, for example.)
Templates are an alternative solution. They have the
disadvantage that they can easily lead to code bloat, and that
to be effective, the initializations have to share a common
pattern; inheritance gives you a lot more freedom. On the other
hand, to use inheritance, you have to make everything needed by
the derived classes available somehow: either protected or via
an accessor function. There's no universally correct solution,
but on the whole, I find that inheritance provides the simpler
solution most of the time.
He wants classes with common functionality, except for the
constructor, which is specialized for each class. That's
exactly what inheritance is for.
Care to show an example?
class Device
{
Protocol* my_protocol;
Layout* my_layout;
public:
Device( Protocol* desired_protocol,
Layout* desired_layout )
: my_protocol( desired_protocol )
, my_layout( desired_layout )
{
}
// ...
};
class SomeSpecificDevice
: private SpecificProtocol // inheritance to control
, private SpecificLayout // order of initialization.
, public Device
{
public:
SomeSpecificDevice() : Device( this, this ) {}
};
And in current C++ you can not inherit constructors, so how
that would be handled?
See above. It's a fairly standard idiom.
Of course, you can easily combine the two, using a template for
the derived class (parametrized on the protocol and the layout).
The derivation still gives you the liberty of handling special
cases differently, however.
The classes' "common functionality" is really common just
textually -- it invokes different functions on objects of
different types.
The original code looked to me more of something along the lines
of the strategy pattern. Where inheritance plays an important
role in the stragety classes.
Inheritance could deal with the "different function" thing
calling a virtual, but is hosed with the different member.
Certainly the class could have parts that are
Looks like something got deleted here.
--
James Kanze