a problem with poliporphism

[Nafai]

Hello. I'll try to explain my problem with an example:

I have the following classes:

class A {
public:
string name;
....
};

class B : public A
{
B(int x) {b=x; name="I am B"; }
int b;
getB() { return b };
};

class C : public A
{
C(int x) {c=x; name="I am C"; }
int c;
getC() { return c; }
};

Now, I need a vector<A*> v;

An there is a function like the following:

void p()
{
...
if(v[i]->name=="I am B"){ v[i]->getB() ...};
...
if(v[j]->name=="I am C") { v[j]->getC() ... };
...
};

It doesn't work because v contains objects of class A, but A doesn't
implement getB() nor getC().
But I need to have in the same vector objets of A, B and C. And I don't want
to declare getB and getC as virtual in A, because these methods will only be
defined in classes B and C respectively.

How can I do that?

Thanks.

[Nafai]

Some corrections:

I have the following classes:

class A {
public:
string name;
...
};

class B : public A
{
int b; public:
B(int x) {b=x; name="I am B"; } getB() { return b };
};

class C : public A
{
int c; public:
C(int x) {c=x; name="I am C"; }
getC() { return c; } };

Now, I need a vector<A*> v;

An there is a function like the following:

void p()
{
...
if(v[i]->name=="I am B"){ v[i]->getB() ...};
...
if(v[j]->name=="I am C") { v[j]->getC() ... };
...
};

It doesn't work because v contains objects of class A, but A doesn't
implement getB() nor getC().
But I need to have in the same vector objets of A, B and C. And I don't
want to declare getB and getC as virtual in A, because these methods will
only be defined in classes B and C respectively.

How can I do that?

Thanks.

[Victor Bazarov]

Nafai wrote:

Some corrections:
More corrections

I have the following classes:

#include <string>
using std::string;
class A {
public:
string name;
...
};

class B : public A
{
int b;
public:
B(int x) {b=x; name="I am B"; }

getB() { return b };
int getB() { return b };
};

class C : public A
{
int c;

public:
C(int x) {c=x; name="I am C"; }
getC() { return c; }

int getC() { return c; }

};

Now, I need a vector<A*> v;

An there is a function like the following:

void p()
{
...
if(v[i]->name=="I am B"){ v[i]->getB() ...};
...
if(v[j]->name=="I am C") { v[j]->getC() ... };
...
};

It doesn't work because v contains objects of class A,
Actually, v contains _pointers_ to objects of class A. It would be
a disaster if v contained _objects_.
but A doesn't
implement getB() nor getC().
But I need to have in the same vector objets of A, B and C. And I don't
want to declare getB and getC as virtual in A, because these methods will
only be defined in classes B and C respectively.

How can I do that?

Declare

virtual int getValue() = 0;

in A and make B and C implement it by calling getB and getC respectively.

V

[Alexandros]

Declare

virtual int getValue() = 0;

in A and make B and C implement it by calling getB and getC respectively.

V

what about if C is like this (A and B are like before):

class C {
int c1, c2;
public:
int getC1() { return c1; }
int getC2() { return c2; }
};

vector<A*> v;
void p()
{
....
v[i]->getC1();
...
v[i]->getC2();
...
}

And another question:

list<A*> l;
A* p = new C(...);
l.push_front(p) ;
l.pop_front();

is *p destroyed?

Or even more: will list<A*>'s destructor destroy all the elements of l ?

[Victor Bazarov]

Alexandros wrote:

Declare

virtual int getValue() = 0;

in A and make B and C implement it by calling getB and getC respectively.

V

what about if C is like this (A and B are like before):

class C {
int c1, c2;
public:
int getC1() { return c1; }
int getC2() { return c2; }
};

vector<A*> v;
void p()
{
....
v[i]->getC1();
...
v[i]->getC2();
...
}

Not going to work. If C and B are so different, they have no business to
reside in the same container to begin with. The only reason for B and C
to have a base class is if they have something _in common_. If they have
_nothing_ in common, what polymorphism can we talk about here?

Of course, you could try to claim that they have the _name_ in common, but
come on, what polymorphism is there if the only thing they share is the
ability to have a name? If that's so, the only thing you can do with them
polymorphically is to learn the names of the objects.
And another question:

list<A*> l;
A* p = new C(...);
l.push_front(p) ;
l.pop_front();

is *p destroyed?
No.
Or even more: will list<A*>'s destructor destroy all the elements of l ?

No, it will not. It has to be done manually (since it was allocated
without 'list's involvement, the list has no business trying to free
them.

V

[Nafai]

Not going to work. If C and B are so different, they have no business to
reside in the same container to begin with. The only reason for B and C
to have a base class is if they have something _in common_. If they have
_nothing_ in common, what polymorphism can we talk about here?

Of course, you could try to claim that they have the _name_ in common, but
come on, what polymorphism is there if the only thing they share is the
ability to have a name? If that's so, the only thing you can do with
them polymorphically is to learn the names of the objects.

That was only an example; classes A,B and C have many things in common.
Actually their only difference is what I show in that example.

[Victor Bazarov]

Nafai wrote:

Not going to work. If C and B are so different, they have no business to
reside in the same container to begin with. The only reason for B and C
to have a base class is if they have something _in common_. If they have
_nothing_ in common, what polymorphism can we talk about here?

Of course, you could try to claim that they have the _name_ in common,
but
come on, what polymorphism is there if the only thing they share is the
ability to have a name? If that's so, the only thing you can do with
them polymorphically is to learn the names of the objects.

That was only an example; classes A,B and C have many things in common.
Actually their only difference is what I show in that example.

Well, then it's not fair to talk about them out of context...

The whole idea of using containers with polymorphic types is that the
objects (through pointers) are used polymorphically . As soon as you have
to figure out the "real" types of objects via some kind of RTTI (your 'if
name is "I am B" ' _is_ RTTI, in essence), you step away from polymorphic
behaviour.

Yes, you can always do

if (v[i]->is_really_of_t ype_B()) { // whatever 'is_really_of_t ype_B' is
B* pb = dynamic_cast<B* >(v[i]);
// use pb however you want
}
else if (v[i]->is_really_of_t ype_C()) { // same here
C* pc = dynamic_cast<C* >(v[i]);

... et cetera ...

Hell, you can write

if (B* pb = dynamic_cast<B* >(v[i])) {
// use pb
}
else if (C* pc = dynamic_cast<C* >(v[i])) {
// use pc
}

and so on. But both approaches _require_ that you know what types derive
from 'A' _ahead_of_time_ , while writing that code. What if I come later
and derive another type from A and want to store it in the same container?
SOL? Or do I have to come in and edit that function and every piece of
code that does that?

While it is possible to circumvent polymorphism in C++, you should
definitely think twice before writing code like that. Write some kind of
special processing code in the base class and make every derived class
override that thus providing _polymorphic_ processing.

You either put effort initially to _keep_ polymorphism, to adhere to OOD
principles, or you don't, then somebody else or maybe you will have to
put some effort _later_ to keep the system working.

V

[jeffc]

"Nafai" <na*******@yaho o.es> wrote in message
news:rK******** ***********@tel enews.teleline. es...

Hello. I'll try to explain my problem with an example:

I have the following classes:

class A {
public:
string name;
...
};

class B : public A
{
B(int x) {b=x; name="I am B"; }
int b;
getB() { return b };
};

class C : public A
{
C(int x) {c=x; name="I am C"; }
int c;
getC() { return c; }
};

Now, I need a vector<A*> v;

An there is a function like the following:

void p()
{
...
if(v[i]->name=="I am B"){ v[i]->getB() ...};
...
if(v[j]->name=="I am C") { v[j]->getC() ... };
...
};

It doesn't work because v contains objects of class A, but A doesn't
implement getB() nor getC().
But I need to have in the same vector objets of A, B and C. And I don't want
to declare getB and getC as virtual in A, because these methods will only be
defined in classes B and C respectively.

How can I do that?

You would come up with some other function name that makes sense in the general
case for all subtypes. What does it do? It just returns a value, that both B
and C seem to share. You haven't given enough information, but right off the
top if my head, I'd say take out "int c" and "int b" and put "int value" in A
instead. Then write a function "getValue" for A, and take out getB and getC.
Then you can write your code as such:

void p()
{
v[i]->getValue();
}
*That* is the point of polymorphism. No "ifs" for the type.

[Jesper Madsen]

"Nafai" <em***@company. com> wrote in message
news:rE******** ***********@tel enews.teleline. es...

Not going to work. If C and B are so different, they have no business to reside in the same container to begin with. The only reason for B and C
to have a base class is if they have something _in common_. If they have _nothing_ in common, what polymorphism can we talk about here?

Of course, you could try to claim that they have the _name_ in common, but come on, what polymorphism is there if the only thing they share is the
ability to have a name? If that's so, the only thing you can do with
them polymorphically is to learn the names of the objects.

That was only an example; classes A,B and C have many things in common.
Actually their only difference is what I show in that example.

There are several ways of doing this:
This way you can sort of downcast without using dynamic_cast, and you know
which classes you allow to cast to in class A. (this is what is done in the
composite pattern)

class C;
class B;

class A {
public:
virtual C* GetC() { return 0; };
virtual B* GetB(){ return 0; };
};

class B : public A{
public:
virtual B* GetB(){ return this; };
};

class C : public A{
public:
virtual C* GetC(){ return this; };
}

or you can implement methods that do nothing on the base class, and has
functionality on some of the derived...
(this is done in state pattern)

class A {
public:
virtual void doStuffB{};
virtual void doStuffC{};
};

class B: public A {
int x_;
public:
virtual void doStuffB{ x_ = 10; };
};

class C: public A {
int y_;
public:
virtual void doStuffC{ y_ = 10;};
};

You can probably solve this in more ways, but what ever way you choose to
solve it, the cleanest one would be to keep the interface between the base
class and its derivee's 100%. You might be able to use use template method
if you want something extra to happen in a derived class.. If you have a
need to add a function, that has nothing to do with the rest of the
hierachy, then take a look at the hierachy again, you might need to refactor
it..

[E. Robert Tisdale]

Nafai wrote:

[snip]

What is poliporphism?