Re: Ok --- *enough* with the private virtual functions...
"Steven E. Harris" <seh@panix.com> schrieb im Newsbeitrag
news:q94lkjsgg0e.fsf@chlorine.gnostech.com...
"norbert.riedlin@web.de" <norbert.riedlin@web.de> writes:
No it can not! It can only be called by base-class members in Java
and additionally by friends in C++.
We must be talking about different things. I was referring to the
following sample -- as short as I could make it to make the proper
point.
The thing I was talking about was:
You said:
"...I see that this protected method can be called from within any
derived
type, perhaps violating some sequencing requirements, but a private
function could also be called in more contexts than the base class
would prefer."
And I asked (concerning your comment about the private function):
"How can the private function be called in other contexts as in the
base
class context?"
==========
#include <iostream>
class B
{
public:
int foo() const
{ return foo_imp(); }
private:
virtual int foo_imp() const = 0;
};
class D : public B
{
public:
int bar() const
{ return foo_imp(); }
private:
int foo_imp() const
{ return 42; }
};
template <class T, class U, class R>
std::ostream& call(std::ostream& os, T const& v, R (U::*f)(), char const*
name)
{ return os << name << ": " << (v.*f)() << '\n'; }
int main(int, char*[])
{
D const d;
call( call( std::cout, d, &B::foo, "foo" ),
d, &D::bar, "bar" );
return 0;
}
==========
Running it prints:
,----
| foo: 42
| bar: 42
`----
Here we have the pattern described upthread: public function foo() in
class B depends upon a private virtual function, foo_imp(). In derived
class D, we see a private implementation of foo_imp() and another
function bar() that also calls foo_imp().
That's what I meant about the private function being callable from
more contexts than the base class author may have preferred: foo_imp()
can be called from foo() /and elsewhere/.
The base-classes author made perfectly clear (and it is enforced by the
compiler) that B::foo_imp() may only be called by members of B.
I think I don't get your point. Again: my point was, that a private
function in B (BTW: virtual or not) may and can only be called by
members of B in Java and C++ and aditionally by friends of B in C++.
Noone else may call B's private functions. Your example above prooves
this point: B calls D's foo_imp() by the usual virtual function call
mechanism. But D cannot manage to call B's version of foo_imp(), even
if B::foo_imp were not pure virtual. D::bar does _not_ call
B::foo_imp(), it does not even attempt to do so. D has to declare its
own version of foo_imp(), otherwise the compiler had emitted an error
message. As I said before: (not even) a derrived class may call private
functions of its base class.
Bye
Norbert
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]