Re: Why use *protected* virtual functions for Template Method
phillip.ngan@gmail.com wrote:
Stephen Dewhurst in "C++ Common Knowledge" pg 78 writes:
"Typically, a Template Method is implemented as a public, nonvirtual
function that calls protected virtual functions."
Why do the virtual functions have to be protected?
they don't have to, also can be public, just meet the real case need
I assume that the virtual functions exist to serve the public
nonvirtual function, and moreover have no relevant meaning outside of
that context. So I can't see why the virtual functions should not be
declared with private access in the base class. Indeed in Stephen's
private member function in the base class is not visible in the derived
class, only visible function can be overridden
code example, the virtual functions are overridden by private
functions in a derived class.
(Please I don't want this thread to stray into "should virtual
functions be non-public": this has been already covered in past
threads)
See this case:
class Ostream {
public:
Ostream& operator<< (int i) {
write(&i, sizeof(int));
return *this;
}
Ostream& operator<< (char c) {
write(&c, sizeof(char));
return *this;
}
protected:
virtual size_t write(void const* buf, size_t size) = 0;
};
class FileOstream : public Ostream {
private: // protected if you don't wanna seal FileOstream
virtual size_t write(void const* buf, size_t) {
// your implementation here
}
};
here,
we have two template methods two *operator<<*
the *write* is called primitive operation, which is never called outside
of _Ostream_ class hirarcheture(to your question again, *public* here is
fine)
, that's why it's *protected* in _Ostream_ to make the derived class can
override it
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]