Re: Simple OO design issue
Hi there,
class YImpl : public XImpl, public Y
{
public:
void func1(int i)
{
// Note XImpl:: scope specifier
XImpl::func1(i);
}
void func2(int i)
{
cout << "YImpl::func2 - i = " << i << endl;
}
};
Ok, this code works and does it correctly. At least technically. In regards
to the design issues, this kind of multiple inheritance may contain more
informatyion than it is required, which is not good in sense of good design.
Actually, in this implementation we are open not only to say that YImpl is
implemented via XImpl [partially] but also let the clients directly access
that part. Consider the following code [yes-yes it is unusual, though
possible];
YImpl y;
y.func1( ); // indirect call to XImpl::func1(). Normal
// unusual part
y.XImpl::func1( ); // direct call to XImpl::func1(). Not normal
What happens here is that we ignore YImpl::func1 and do smth "not intended
to do"; calling a part of implementation of YImpl::func1 outside of
YImpl::func1.
Well, to overcome, we may do a private inheritance;
class YImpl : private XImpl, public Y {
Now the line y.XImpl::func1( ) will cause a compile time error. Ok.
Still the design might be violated; perheps YImpl object as itself has
nothing to do with XImpl objects. But the following works as well;
YImpl y;
((XImpl *)&y)->func1();
Anyway, I think aggregating XImpl object inside of YImpl is a good solution
if there is no object-oriented relations between YImpl and XImpl instances.
--
======
Arman
"MrAsm" wrote:
On Fri, 01 Jun 2007 00:55:56 -0700, obrianpatrick@gmail.com wrote:
Hi,
I am having the following design
problem:
I have two interfaces X and Y. Y is derived from X as the following:
__interface X
{
public:
virtual void func1(int) = 0;
};
I think that __interface would be more useful in a context of defining
COM interfaces...
For plain C++, I prefer:
class X
{
public:
// Don't forget the virtual destructor!
virtual ~X() {}
virtual void func1( int ) = 0;
};
And similar for Y interface:
class Y : public X
{
public:
virtual ~Y() {}
virtual void func2(int) = 0;
};
(I don't know if __interface also defines a virtual destructor, which
is important when you delete C++ objects that are in a hierarchy
chain.)
class YImpl: public Y
will not allow me to use the func1() implementation of XImpl. I have
to rewrite the same function in YImpl then.
You could code like this:
class YImpl : public Y
{
public:
void func1(int i)
{
// Route function call to member object
mX.func1(i);
}
void func2(int i)
{
cout << "YImpl::func2 - i = " << i << endl;
}
private:
XImpl mX;
};
In that code, I just created a member instance of XImpl into YImpl,
and route the func1 call to XImpl data member.
On the other hand inheriting YImpl multiply from XImpl and Y as
as
class YImpl: public XImpl, public Y
is not a good idea as X interface is included twice (and the VC++
complier is not allowing it either, rightly complaining that func1 is
ambiguous).
In this case, you might do:
class YImpl : public XImpl, public Y
{
public:
void func1(int i)
{
// Note XImpl:: scope specifier
XImpl::func1(i);
}
void func2(int i)
{
cout << "YImpl::func2 - i = " << i << endl;
}
};
MrAsm