Re: why private virtual function?
On Mar 17, 12:15 pm, "Alf P. Steinbach" <al...@start.no> wrote:
* Abhishek Padmanabh:
On Mar 16, 1:46 am, "Alf P. Steinbach" <al...@start.no> wrote:
Example:
<code>
class Base
{
private:
void foo() {}
public:
void bar() {}
};
struct Mixin { void foo() {} };
class Derived: public Base, public Mixin
{
public:
void bar() { foo(); } // Uh oh.
};
int main()
{
Derived().bar();}
</code>
In each specific case there are simple workarounds, e.g. here a
'using'-declaration or qualification, but IMHO there's something not qu=
ite right
about the scheme.
using declaration does not work here and rightly so. Something that is
private as declared by the "owner"/the base class itself should not be
easy enough to break into to make it visible. If the derived class
opts to take it (inherit) privately, using works and probably rightly
so as it is the decision of the derived class about what it wants.
Still, using declaration looks like a hack to circumvent the bad
decisions already taken or just a way to reuse code causing additional
coupling apart from what inheritance already causes.
I'm sorry, your comment is not meaningful to me, and it's also technically=
incorrect.
It seems you have failed to understand the code, as well as what it was al=
l about.
Try to compile the code, for example.
Sorry if I was not clear. I tried compiling comeau online. I get the
following error:
"ComeauTest.c", line 13: error: "Derived::foo" is ambiguous
void bar() { foo(); } // Uh oh.
^
which is a little strange and probably mis-leading. When you uncomment
the derivation from Mixin as below (and additionally even put a using
declaration for Base::foo):
class Base
{
private:
void foo() {}
public:
void bar() {}
};
//struct Mixin { void foo() {} };
class Derived: public Base//, public Mixin
{
public:
using Base::foo;
void bar() { foo(); } // Uh oh.
};
int main()
{
Derived().bar();
}
It fails to compile with below errors:
"ComeauTest.c", line 12: error: function "Base::foo" (declared at line
4) is
inaccessible
using Base::foo;
^
"ComeauTest.c", line 13: error: function "Base::foo" (declared at line
4) is
inaccessible
void bar() { foo(); } // Uh oh.
Hope this clears what I was pointing out (by me):
using declaration does not work here and rightly so. Something that is
private as declared by the "owner"/the base class itself should not be
easy enough to break into to make it visible.
The later comment (by me):
If the derived class
opts to take it (inherit) privately, using works and probably rightly
so as it is the decision of the derived class about what it wants.
Still, using declaration looks like a hack to circumvent the bad
decisions already taken or just a way to reuse code causing additional
coupling apart from what inheritance already causes
This is relevant when the inheritance been private with Base::foo as
public, using declaration would have been helpful in extending the
interface of Derived with the base foo. This is not directly relevant
to the above point. Private inheritance is a private contract between
the base class and the privately derived class. If it exposes the same
interface as base class using the using declaration, that is in a way
exposing the base class through derived class to external code.
External code is not directly related to base class but a change in
base class for the foo() function affected it using the derived class
foo() function (say, a signature change). This shouldn't happen and
should be probably protected in privately derived class using a
seperate function (which can call the base foo as an option). This way
just the privately derived class needs to change due to the changes in
base class foo() and not the external which might have directly used
foo() via derived. Hope I could express clearly here?