Re: Ok --- *enough* with the private virtual functions...

"norbert.riedlin@web.de" <norbert.riedlin@web.de> writes:


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.

==========
#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/.

--
Steven E. Harris

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]