Re: derived class and virtual function

From:

=?ISO-8859-1?Q?=D6=F6_Tiib?= <ootiib@hot.ee>

Newsgroups:

comp.lang.c++

Date:

Tue, 17 Aug 2010 17:13:12 -0700 (PDT)

Message-ID:

<970c78f2-2bb2-40f9-b933-2b8b00338a6b@k10g2000yqa.googlegroups.com>

On 18 aug, 02:54, red floyd <no.spam.h...@its.invalid> wrote:

On 8/17/2010 1:54 AM, James Kanze wrote:

On Aug 13, 10:09 am, "Francesco S. Carta"<entul...@gmail.com> wrote:

Francesco S. Carta<entul...@gmail.com>, on 13/08/2010 10:39:51, wrote:

subramanian10...@yahoo.com, India<subramanian10...@yahoo.com>, on
13/08/2010 01:29:13, wrote:

In Stanley Lippman's 'C++ Primer Fourth Edition', in page 564, the
following is mentioned:

"A virtual function in the derived class can return a reference or
pointer to a class that is PUBLICLY derived from the type returned b=

the base class function."

I am unable to understand this sentence. Kindly explain it with
program sample.

IIUIC, that means that if you have a function with signature "virtual
Base* Clone() const;" in the base class, then the implementation of t=

same function in the derived class can be: "Base* Clone() const { ret=

urn

new Derived(*this); }" - just an example that assumes Derived is
copy-constructible, of course.

There is either something wrong in that sentence, in my understanding
or in my compiler - or my settings thereof - because it allows me to
return a pointer to Derived where Base is private:

In your understanding, I think, because...

//-------

#include<iostream>

using namespace std;

class Base {
      public:
      Base(int data = 0) : data(data) {};
      Base(const Base& base) : data(base.data) {};
      virtual Base* Clone() const {
          cout<< "cloning Base"<< endl;
          return new Base(*this);
      }
      int Data() const {
          return data;
      }
      private:
      int data;
};

class Derived : private Base {
      public:
      Derived(int data = 0) : Base(data) {};
      Derived(const Derived& derived) : Base(derived) {};
      Base* Clone() const {

Here, you're still returning a Base. Any conversion takes place
in Derived (where the derivation is visible).

Try changing the return type to Derived*; the compiler should
complain then.

See =A710.3/5 in the standard for details.

James, I thought that the compiler should *not* complain if the
return type of Derived::Clone was Derived*. Isn't that a
covariant return type?

Did you eyeball =A710.3/5? Base is not accessible base class of Derived
so it is not a covariant there by standard.