virtual functions/generic access

[Mark Foley]

I am implementing some functionality where there is a single
base class 'A' which provides some common functionality

There are then two classes derived from 'A', call them 'B' and 'C'.
Both 'B' and 'C' define functions specific only to their class. Somethng
like...
class A
{
void doX();
void doY();
}

class B : class A
{
void getInfo();
char * getBInfo();
}

class C : class A
{
void getInfo();
char * getCInfo();
}
I then have a list of objects. Some are based on 'B', some are based
on 'C', but I would like to treat them generically.

ob[0]->type.doX(); // always ok
ob[0]->type.getInfo(); // always ok
ob[0]->type.getCInfo(); // only ok if type is Class C

I know if I make getBInfo() virtual in the base class then I can
make the above call regardless. But then I have to provide some
return value for it in class A.

If I make it a pure virtual, then I need to provide an implementation
for it in the derived class.

Is there a way to treat a list of objects like this generically without
having to know their
actual type?

It seems kludgey to have something like:

virtual char * getBInfo() {return NULL};

in my base class, but perhaps that's the way it's done.

Thanks
Mark

[Victor Bazarov]

Mark Foley wrote:

I am implementing some functionality where there is a single
base class 'A' which provides some common functionality

There are then two classes derived from 'A', call them 'B' and 'C'.
Both 'B' and 'C' define functions specific only to their class.
Somethng like...
class A
{

Probably

public:

void doX();
void doY();
}

;

>
class B : class A

You mean

class B : public A

{

Most likely

public:

void getInfo();
char * getBInfo();
}

;

>
class C : class A

You mean

class C : public A

{
void getInfo();
char * getCInfo();
}

;

>
I then have a list of objects. Some are based on 'B', some are based
on 'C', but I would like to treat them generically.

ob[0]->type.doX(); // always ok
ob[0]->type.getInfo(); // always ok
ob[0]->type.getCInfo(); // only ok if type is Class C

Are you claiming that that's what happens or setting forth requirements?

>
I know if I make getBInfo() virtual in the base class then I can
make the above call regardless.

Regardless of what? Which of the above calls is 'getBInfo()'?

But then I have to provide some
return value for it in class A.

If you intend to make it virtual and have it in 'A', you need to give
it the _covariant_ return value type. It can't just be "some".

If I make it a pure virtual, then I need to provide an implementation
for it in the derived class.

Only if you intend to instantiate the derived class.

Is there a way to treat a list of objects like this generically
without having to know their
actual type?

The only way to do that is to give them polymorphic behaviour (through
virtual functions, as you already mentioned).

It seems kludgey to have something like:

virtual char * getBInfo() {return NULL};

in my base class, but perhaps that's the way it's done.

It's _a_ way to do it. Whether it's the best way, is debatable.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Maarten Kronenburg]

"Mark Foley" wrote in message

>
I am implementing some functionality where there is a single
base class 'A' which provides some common functionality

There are then two classes derived from 'A', call them 'B' and 'C'.
Both 'B' and 'C' define functions specific only to their class. Somethng
like...
class A
{
void doX();
void doY();
}

class B : class A
{
void getInfo();
char * getBInfo();
}

class C : class A
{
void getInfo();
char * getCInfo();
}
I then have a list of objects. Some are based on 'B', some are based
on 'C', but I would like to treat them generically.

ob[0]->type.doX(); // always ok
ob[0]->type.getInfo(); // always ok
ob[0]->type.getCInfo(); // only ok if type is Class C

I know if I make getBInfo() virtual in the base class then I can
make the above call regardless. But then I have to provide some
return value for it in class A.

If I make it a pure virtual, then I need to provide an implementation
for it in the derived class.

Is there a way to treat a list of objects like this generically without
having to know their
actual type?

It seems kludgey to have something like:

virtual char * getBInfo() {return NULL};

in my base class, but perhaps that's the way it's done.

Thanks
Mark

Mark,
Yes when you override a virtual function it must be declared as virtual in
the base class.
You can read more about virtual functions in
The C++ Programming Language, 3rd. ed., par. 12.2.6
and also on:
http://www.parashift.com/c++-faq-lit...functions.html
Regards, Maarten.

[Jim Langston]

"Mark Foley" <fo****@meftechno.comwrote in message
news:46***********************@roadrunner.com...

>
I am implementing some functionality where there is a single
base class 'A' which provides some common functionality

There are then two classes derived from 'A', call them 'B' and 'C'.
Both 'B' and 'C' define functions specific only to their class. Somethng
like...
class A
{
void doX();
void doY();
}

class B : class A
{
void getInfo();
char * getBInfo();
}

class C : class A
{
void getInfo();
char * getCInfo();
}
I then have a list of objects. Some are based on 'B', some are based
on 'C', but I would like to treat them generically.

ob[0]->type.doX(); // always ok
ob[0]->type.getInfo(); // always ok
ob[0]->type.getCInfo(); // only ok if type is Class C

I know if I make getBInfo() virtual in the base class then I can
make the above call regardless. But then I have to provide some
return value for it in class A.

If I make it a pure virtual, then I need to provide an implementation
for it in the derived class.

Is there a way to treat a list of objects like this generically without
having to know their
actual type?

It seems kludgey to have something like:

virtual char * getBInfo() {return NULL};

in my base class, but perhaps that's the way it's done.

Using polymorphism you can ask the instance if it is type C.

if ( dynamic_cast<C*>( ob[0] ) != NULL )
dynamic_cast<C*>( ob[0] )->getCInfo(); // only ok if type is Class
C