Virtual Methods Question

[Daniel]

I have the following three classes

class A
{
public:
virtual void f() = 0;
};

class B: public A
{
public:
virtual void f();
};

void B::f()
{
cout << "B::f()";
}

class C: public B
{
public:
void f();
};

void C::f()
{
cout << "C::f()";
}
main()
{
A* x = new C();

x->f();
}

The above program prints the following:

B::f()

But, I wanted the program to print

C::f()

Why is the program doing this? Is there any way for me to have C's f()
method invoked instead of B's f() method? I am using the GNU compiler
for VxWorks 5.5. Thanks in advance for any help.
-Daniel

[roberts.noah]

Daniel wrote:

The above program prints the following:

B::f()

But, I wanted the program to print

C::f()

prints "C::f()" over here. That is what it should do.

[Frank Schmidt]

"Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
news:11******** **************@ v46g2000cwv.goo glegroups.com.. .

class C: public B
{
public:
void f();
};

you miss a virtual there.

f~

[Peter_Julian]

"Frank Schmidt" <[e-mail] > wrote in message
news:dt******** **@online.de...
|
| "Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
| news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
|
| > class C: public B
| > {
| > public:
| > void f();
| > };
|
| you miss a virtual there.
|
| f~
|

Nope, if the pure-abstract or base class specifies that void f() is virtual
then its virtual in the entire hierarchy. Regardless whether the derived
classes have that function as virtual or not.

[roberts.noah]

Peter_Julian wrote:

"Frank Schmidt" <[e-mail] > wrote in message
news:dt******** **@online.de...
|
| "Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
| news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
|
| > class C: public B
| > {
| > public:
| > void f();
| > };
|
| you miss a virtual there.
|
| f~
|

Nope, if the pure-abstract or base class specifies that void f() is virtual
then its virtual in the entire hierarchy. Regardless whether the derived
classes have that function as virtual or not.

I thought it stopped at C meaning that any subclass of C would not be
able to polymorphically override f().

[Peter_Julian]

"Daniel" <da***********@ gmail.com> wrote in message
news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
| I have the following three classes
|
| class A
| {
| public:
| virtual void f() = 0;
| };

undefined behaviour.
1) you failed to invoke delete x
2) In main() you are using a base pointer to a derived object and yet you
have not declared a virtual destructor in class A.

#include <iostream>
#include <ostream>

class A
{
public:
virtual ~A() { std::cout << "~A()\n"; }
virtual void f() = 0;
};

<snip>

|
| main()

int main()

| {
| A* x = new C();

A* x = new C;

|
| x->f();

delete x;

| }
|
| The above program prints the following:
|
| B::f()
|
| But, I wanted the program to print
|
| C::f()
|
| Why is the program doing this? Is there any way for me to have C's f()
| method invoked instead of B's f() method? I am using the GNU compiler
| for VxWorks 5.5. Thanks in advance for any help.
|

Your compiler is invoking the C() ctor correctly(which requires that both
A() and B() get allocated first) and then drops the allocation of the
derived C as if it were a temporary (which is not appropriate but otherwise
not strictly enforced). The remnant is a valid B-type object.

That should be fixed with the correct statement:
A* x = new C; // correctly invokes the default ctor to completion

Note that your problem, other than not using delete x at all (shame), has a
much more critical issue than the one you raise. If you don't provide a
virtual d~tor in class A then ~B() or ~C() will never be invoked. Thats a
guarenteed memory leak.

Test it:

int main()
{
A* x = new C;

x->f();

delete x;

return 0;
}

/* correct output
C::f()
~C()
~B()
~A()
*/

but what you are getting with the compiler generated d~tor(s) is:

C::f()
~A()

which is a partial destruction and a memory leak. bad news.

Moral of the story:

a) never, ever new if you don't delete
b) never, ever new[] if you don't [] delete
c)if you derive and destroy via a pointer to base:
***always provide a virtual d~tor***
or suffer the consequences.

[Peter_Julian]

<ro**********@g mail.com> wrote in message
news:11******** **************@ z34g2000cwc.goo glegroups.com.. .
|
| Peter_Julian wrote:
| > "Frank Schmidt" <[e-mail] > wrote in message
| > news:dt******** **@online.de...
| > |
| > | "Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
| > | news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
| > |
| > | > class C: public B
| > | > {
| > | > public:
| > | > void f();
| > | > };
| > |
| > | you miss a virtual there.
| > |
| > | f~
| > |
| >
| > Nope, if the pure-abstract or base class specifies that void f() is
virtual
| > then its virtual in the entire hierarchy. Regardless whether the derived
| > classes have that function as virtual or not.
|
| I thought it stopped at C meaning that any subclass of C would not be
| able to polymorphically override f().
|

That doesn't make sense, and with good reason. The is_a relationship is
critical here. If you publicly derive from C and declare D, then its implied
that the D-type is_a C-type as well. You can perfectly well derive like
so...

class D : public C
{
};

and never declare void f() since a call like so...

A* p_a = new D;
p_a->f(); // will call C::f(), no problem - its expected
delete p_a; // invokes 4 d~tors - ~D, ~C, ~B and ~A

If there was a way to prevent the inheritance of a pure-virtual member
function, polymorphism would be broken. And there is...
___
The answer to your quest is simple: composition or private inheritance.
Sometimes its more important to understand when not_to_use polymorphic
inheritance.
Neither of these represent an "is_a" inheritance scheme.

class D
{
C c;
public:
void f() { } // not virtual
};

or D in_terms_of C, where D is_not C or B or A. This is also a form of
composition, not polymorphic inheritance...

class D : private C
{
void f() { std::cout << "D::f()\n"; } // not virtual
};

int main()
{
D d;
d.f();
}

/*
D::f() // not virtual
~D()
~C()
~B()
~A()
*/

[Dietmar Kuehl]

Daniel wrote:

The above program prints the following:

B::f()

You must have made a copying error: the program does not compile
for me. There are missing include statements, namespace qualification,
and a missing return type of 'main()'. Once I fixed these problems,
the program prints "C::f()", as it should.
--
<mailto:di***** ******@yahoo.co m> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

[Frank Schmidt]

"Peter_Juli an" <[e-mail] digo.ca> schrieb im Newsbeitrag
news:fN******** ***********@new s20.bellglobal. com...

"Frank Schmidt" <[e-mail] > wrote in message
news:dt******** **@online.de...
|
| "Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
| news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
|
| > class C: public B
| > {
| > public:
| > void f();
| > };
|
| you miss a virtual there.
|
| f~
|

Nope, if the pure-abstract or base class specifies that void f() is
virtual
then its virtual in the entire hierarchy. Regardless whether the derived
classes have that function as virtual or not.

say that to a compiler, which calls B::f() with the given the source

[roberts.noah]

Peter_Julian wrote:

<ro**********@g mail.com> wrote in message
news:11******** **************@ z34g2000cwc.goo glegroups.com.. .
|
| Peter_Julian wrote:
| > "Frank Schmidt" <[e-mail] > wrote in message
| > news:dt******** **@online.de...
| > |
| > | "Daniel" <da***********@ gmail.com> schrieb im Newsbeitrag
| > | news:11******** **************@ v46g2000cwv.goo glegroups.com.. .
| > |
| > | > class C: public B
| > | > {
| > | > public:
| > | > void f();
| > | > };
| > |
| > | you miss a virtual there.
| > |
| > | f~
| > |
| >
| > Nope, if the pure-abstract or base class specifies that void f() is
virtual
| > then its virtual in the entire hierarchy. Regardless whether the derived
| > classes have that function as virtual or not.
|
| I thought it stopped at C meaning that any subclass of C would not be
| able to polymorphically override f().
|

That doesn't make sense, and with good reason. The is_a relationship is
critical here. If you publicly derive from C and declare D, then its implied
that the D-type is_a C-type as well. You can perfectly well derive like
so...

class D : public C
{
};

and never declare void f() since a call like so...

You totally missed my point. Doesn't matter because I was wrong but
still, I said one thing and you went off in a totally different
direction.