Re: why private virtual function?
On Mar 17, 1:03 pm, "Alf P. Steinbach" <al...@start.no> wrote:
* Abhishek Padmanabh:
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 =
quite 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 technica=
lly
incorrect.
It seems you have failed to understand the code, as well as what it was=
all 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):
Well OK. You altered the code to try to do something silly, and that fa=
iled.
It's like, darn Microsoft, yer Windoze programming examples are all rotten=
cause
they don't work for me when I change 'em in willy-nilly ways, especially t=
he
examples showing incorrect ways to do to things don't work for me.
:-) Ok, now I got what you meant by :
"<...snip...>does not mean it can be ignored as an implementation
detail of the base class, that
derived classes can't simply politely ignore the private parts of base
classes
<...snip...>but IMHO there's something not quite right
about the scheme."
That the name look-up should have ignored Base::foo but it does not.
Right?
Proper use of a using-declaration to make the code do what it was "meant" =
to
would be
using Mixin::foo;
I leave it as an exercise
Yeah, of course. It works but it is strange that the Base::foo which
is private in base is still being considered for look-up. I had not
come across such a case until now. And as in my above samples, there
is no way to make the Base::foo accessible in Derived, so it should
have been ignored. What is the use of the inclusion if there isn't a
way to access Base::foo in Derived (or is there?) ?
for the student (heh, :-))
You may smile at my misinterpretation of your post. :-) I am not a
student as such but do keep learning things. That way, I am a student,
of course. :-) And thank you, you have been good help in the past.