I don't get it

[Jo]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//-----------------------------------------------------------------------------
class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//-----------------------------------------------------------------------------
class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//-------------------------------------------------------------------------------
void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.
}
//-----------------------------------------------------------------------------

So the hot spot is the bp2=(B*)p;

What's wrong with that???

I can imagine someone saying "p is not pointing to a B object".
But if you think about it, conceptually, it does, imho.

So is it more a technical matter of compiling this!?

Maybe i'm stupid and/or missing something essential about C++.

If so, please give me a link to where i can study this right.

Cheers,

Jo

 

[Bharath]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}};

//-----------------------------------------------------------------------------
class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}};

//-----------------------------------------------------------------------------
class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}};

//-------------------------------------------------------------------------------
void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.}

//-----------------------------------------------------------------------------

So the hot spot is the bp2=(B*)p;

What's wrong with that???

I can imagine someone saying "p is not pointing to a B object".
But if you think about it, conceptually, it does, imho.

So is it more a technical matter of compiling this!?

Maybe i'm stupid and/or missing something essential about C++.

If so, please give me a link to where i can study this right.

Cheers,

Jo

I re-wrote your test function like this -
int main() {

B *bp1,*bp2;
C c,*cp1;
void *p;
int a;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp2=(B*)p;
std::cout<<p<<"\n";
std::cout<<bp2;
std::cin>>a;
}

I printed the value in p and also in bp2. Both are one and the same.
On my m/c the O/P was -
0x22fe28
0x22fe28

Why do you think, in your program, resulting bp2 is WRONG?

 

[Jo]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}};

//-----------------------------------------------------------------------------
class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}};

//-----------------------------------------------------------------------------
class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}};

//-------------------------------------------------------------------------------
void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.}

//-----------------------------------------------------------------------------

So the hot spot is the bp2=(B*)p;

What's wrong with that???

I can imagine someone saying "p is not pointing to a B object".
But if you think about it, conceptually, it does, imho.

So is it more a technical matter of compiling this!?

Maybe i'm stupid and/or missing something essential about C++.

If so, please give me a link to where i can study this right.

Cheers,

Jo

I re-wrote your test function like this -
int main() {

B *bp1,*bp2;
C c,*cp1;
void *p;
int a;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp2=(B*)p;
std::cout<<p<<"\n";
std::cout<<bp2;
std::cin>>a;
}

I printed the value in p and also in bp2. Both are one and the same.
On my m/c the O/P was -
0x22fe28
0x22fe28

Why do you think, in your program, resulting bp2 is WRONG?

Because i got runtime problems.

So i narrowed down everything to the above code.

Running this on my PC gives a wrong bp2 pointer. I can see it in the
"Watch" panel.

And i also did a similar thing than you: at the end of the test/main
function i did a

OutputDebugString(cp3->text_a);
OutputDebugString(cp3->text_b);
OutputDebugString(cp3->text_c);

This gives rubbish for text a!!!

Compilation is done with Visual C++ 7.1.3088

 

[John Harrison]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//-----------------------------------------------------------------------------

class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//-----------------------------------------------------------------------------

class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//-------------------------------------------------------------------------------

void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2 is
already wrong.
}
//-----------------------------------------------------------------------------


So the hot spot is the bp2=(B*)p;

What's wrong with that???

I can imagine someone saying "p is not pointing to a B object".
Right.

But if you think about it, conceptually, it does, imho.

No, it doesn't.

So is it more a technical matter of compiling this!?

No the code is wrong.

Maybe i'm stupid and/or missing something essential about C++.

I doubt you're stupid but you're certainly missing something essential.

If so, please give me a link to where i can study this right.

I have no idea why you think that code should be right, that is my problem.

Perhaps you are expecting an ordinary cast to work like a dynamic_cast?
When you write

bp2=(B*)p; // resulting bp2 is WRONG!

you are expecting the program to 'discover' that there a B object hidden
inside the object that p is pointing to?

If so google for dynamic_cast, or better still read a good book.

john

 

[Andre Kostur]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//---------------------------------------------------------------------
-------- class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//---------------------------------------------------------------------
-------- class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//---------------------------------------------------------------------
---------- void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.
}
//---------------------------------------------------------------------
--------

So the hot spot is the bp2=(B*)p;

What's wrong with that???

Because you are casting a p back into a pointer type that it wasn't
originally. p was originally a C*. You need to cast it back into a C*
first.

I can imagine someone saying "p is not pointing to a B object".
But if you think about it, conceptually, it does, imho.

Nope. It may be pointing at an A obect.

So is it more a technical matter of compiling this!?

Maybe i'm stupid and/or missing something essential about C++.

If so, please give me a link to where i can study this right.

Standard says you can cast a pointer to object into a void*, but you can
only cast the void* back into the pointer type that it was originally.
Anything else is undefined behaviour.

<Implementation-specific behaviour>
What's probably happening in your case is that the memory layout of your
object is A->B->C. So when you take your C* (which is effectively also
an A*, but is _not_ a B*...), hammer it into a void*, and then re-form it
as a B*, you are effectively casting an A* to a B*. Since they're
unrelated types, who knows what the operations on B do to an A object.

So.. you should cast that void* to a C* first, then assign the C* to a B*
(no cast required). The compiler will know at that point that you're
upcasting and will adjust the pointer value accordingly.

</Implementation-specific behaviour>

 

[Jo]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//---------------------------------------------------------------------
-------- class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//---------------------------------------------------------------------
-------- class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//---------------------------------------------------------------------
---------- void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.
}
//---------------------------------------------------------------------
--------

So the hot spot is the bp2=(B*)p;

What's wrong with that???

Because you are casting a p back into a pointer type that it wasn't
originally. p was originally a C*. You need to cast it back into a C*
first.

In the real code, i don't know yet what the type is.
I first need to get a B pointer, then i can deduce the target class.

Do i understand it right that this problem would not occur if

Nope. It may be pointing at an A obect.

That's technically speaking, not conceptually, imo.

If C is derived from A & B, then a C object IS an A and IS a B. At the
same time.

But i understand that at a certain point we must transition from
concepts into practical technology.

What i mean is: in practice: p cannot point to both the A and B instance
at the same time, so you're right about that.

So that's where we come into the implementation specifics.

Standard says you can cast a pointer to object into a void*, but you can
only cast the void* back into the pointer type that it was originally.
Anything else is undefined behaviour.

<Implementation-specific behaviour>
What's probably happening in your case is that the memory layout of your
object is A->B->C. So when you take your C* (which is effectively also
an A*, but is _not_ a B*...), hammer it into a void*, and then re-form it
as a B*, you are effectively casting an A* to a B*. Since they're
unrelated types, who knows what the operations on B do to an A object.

So.. you should cast that void* to a C* first, then assign the C* to a B*
(no cast required). The compiler will know at that point that you're
upcasting and will adjust the pointer value accordingly.

</Implementation-specific behaviour>

Cfr above: i don't know that i should go to a C until i got an A first,
because the A class contains some class specific definitions.

Now do i understand it right that the problem comes from the fact that
i'm using a void* ?

Would this be legal then:

// quick recap: class C is derived from both class A and B

A *ap;
B *bp;
C c,*cp;

cp=&c;
ap=cp;
bp=(B*)ap;

or the last line being

bp=static_cast<B*>(ap);

which is the same, right?

(i'm not laisy, i googled about it, but it's still not 100% clear)

 

[Jo]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//-----------------------------------------------------------------------------

class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//-----------------------------------------------------------------------------

class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//-------------------------------------------------------------------------------

void test() {

B *bp1,*bp2;
C c,*cp1,*cp2,*cp3;
void *p;

strcpy(c.text_a,"hello a");
strcpy(c.text_b,"hello b");
strcpy(c.text_c,"hello c");
cp1=&c;
p=cp1;
bp1=cp1; // ok
bp2=(B*)p; // resulting bp2 is WRONG!
cp2=(C*)p; // ok
cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2
is already wrong.
}
//-----------------------------------------------------------------------------


So the hot spot is the bp2=(B*)p;

What's wrong with that???

I can imagine someone saying "p is not pointing to a B object".

Right.

But if you think about it, conceptually, it does, imho.

No, it doesn't.

So is it more a technical matter of compiling this!?

No the code is wrong.

Maybe i'm stupid and/or missing something essential about C++.

I doubt you're stupid but you're certainly missing something essential.

If so, please give me a link to where i can study this right.

I have no idea why you think that code should be right, that is my
problem.

Imho, if class C is derived from A and B, then C IS an A and a B at the
same time, conceptually.

But i'm understanding that there is a technical implementation problem here.

I thought the compiler could figure that out, but i'm clearly over
estimating the compiler and/or C++.

Anyway, it's off topic to go deeper in this. Although that would be a
nice discussion.

So i'll focus on the practical problem here.

Perhaps you are expecting an ordinary cast to work like a
dynamic_cast? When you write

bp2=(B*)p; // resulting bp2 is WRONG!

you are expecting the program to 'discover' that there a B object
hidden inside the object that p is pointing to?

If so google for dynamic_cast, or better still read a good book.

I understand that a dynamic_cast cannot do a base-to-derived conversion,
so that's not the solution here.
And a static_cast doesn't seem to make any difference, because i'm
already doing static casts right, just in the 'old' way.

So i'm still looking for the solution for this situation

class A {

public:
virtual long GetClassID() { return(' A'); }
};


class B {

public:
// some class data & funx
};

class C : public class A, public class B {

public:
virtual long GetClassID() { return(' C'); }
};


foo1(C *cp) {
...
foo2(cp);
...
}

foo2(A *ap) {

if (ap->GetClassID==' C') {
C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ?
}
}

 

[Jo]

class A {

public:

char text_a[100];

A() { *text_a=0; }
~A() {}
};
//-----------------------------------------------------------------------------
class B {

public:

char text_b[100];

B() { *text_b=0; }
~B() {}
};
//-----------------------------------------------------------------------------
class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//-----------------------------------------------------------------------------


In the context of pointer casting: Does it matter for ansi C++ if class
C is derived from A then B, or from B then A ?

 

[John Harrison]

I understand that a dynamic_cast cannot do a base-to-derived conversion,
so that's not the solution here.

dynamic_cast does do base to derived conversion, that's it's main use.
Where are you getting your information?

john

 

[John Harrison]

//-----------------------------------------------------------------------------

class C : public A, public B {

public:

char text_c[100];

C() { *text_c=0; }
~C() {}
};
//-----------------------------------------------------------------------------



In the context of pointer casting: Does it matter for ansi C++ if class
C is derived from A then B, or from B then A ?

No it doesn't matter.

john

 

[Pete Becker]

Imho, if class C is derived from A and B, then C IS an A and a B at the
same time, conceptually.

But i'm understanding that there is a technical implementation problem
here.

I thought the compiler could figure that out, but i'm clearly over
estimating the compiler and/or C++.

The compiler can, indeed, figure out the relation between a C*, the
corresponding A*, and the corresponding B*. The problem is that you're
not dealing with a C*, but with a void*. The code tells the compiler
that p points to untyped data, and that it should treat the address of
that untyped data as the address of an object of type B. The compiler
did exactly what you told it to do. The only valid conversion you can
apply to that void* is to cast it back to the type of the original
pointer. (C*)p, as you've seen, works just fine. (B*)(C*)p would give
you the address of the B subobject.

--

-- Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com)
Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." (www.petebecker.com/tr1book)

 

[Thomas J. Gritzan]

Imho, if class C is derived from A and B, then C IS an A and a B at the
same time, conceptually.

But i'm understanding that there is a technical implementation problem
here.

In the OP you tried to get a B* from a void*. A void pointer is everything
and nothing, the compiler cannot know what type of object it points to.
So avoid void*. Avoid c-style cast, too. With C++ style cast, the compiler
can warn you whats wrong using them.

I thought the compiler could figure that out, but i'm clearly over
estimating the compiler and/or C++.

Anyway, it's off topic to go deeper in this. Although that would be a
nice discussion.

When it's a language thing, it is on-topic.

I understand that a dynamic_cast cannot do a base-to-derived conversion,
so that's not the solution here.

dynamic_cast can, and is exactly the right tool, to do base-to-derived
conversion. It's like static_cast with an explicit runtime type check.

So i'm still looking for the solution for this situation

class A {

public:
virtual long GetClassID() { return(' A'); }
}; [...]
class C : public class A, public class B {

public:
virtual long GetClassID() { return(' C'); }
};


foo1(C *cp) {
...
foo2(cp);
...
}

foo2(A *ap) {

if (ap->GetClassID==' C') {
C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ?
}
}

When you know that an A* points to a C object, you can static_cast it to a
C*. But why inventing your own RTTI? You can use typeid and dynamic_cast
instead.

 

[Jo]

dynamic_cast does do base to derived conversion, that's it's main use.
Where are you getting your information?

I got that from http://www.cplusplus.com/doc/tutorial/typecasting.html

But i was just reading another webpage where they indeed use
base-to-derived dynamic casts...

Did i misunderstand the cplusplus page?

Anyway, i prefer not to use RTTI.

 

[Jo]

The compiler can, indeed, figure out the relation between a C*, the
corresponding A*, and the corresponding B*. The problem is that you're
not dealing with a C*, but with a void*. The code tells the compiler
that p points to untyped data, and that it should treat the address of
that untyped data as the address of an object of type B. The compiler
did exactly what you told it to do. The only valid conversion you can
apply to that void* is to cast it back to the type of the original
pointer. (C*)p, as you've seen, works just fine. (B*)(C*)p would give
you the address of the B subobject.

So the very problem was the void*, right?

So is all this correct then: (supposing the same class hierarchy as
before, where C is derived from A and B)

C *cp=new C;
B *bp=cp;
C *cp2=(C*)bp;
A *ap=(A*)bp;

 

[Andre Kostur]

[snip example. Important point: There is a class C which inherits from A
& B. A & B are otherwise unrelated]

In the real code, i don't know yet what the type is.
I first need to get a B pointer, then i can deduce the target class.

Do i understand it right that this problem would not occur if

if... ?

That's technically speaking, not conceptually, imo.

If C is derived from A & B, then a C object IS an A and IS a B. At the
same time.

Sure... within the constraints of the language. Means you can pass a C
to something that takes an A, or to something that takes a B. But you
went and removed all type data from the object when it became a void*.
You need to get that pointer back onto the right track first.

But i understand that at a certain point we must transition from
concepts into practical technology.

What i mean is: in practice: p cannot point to both the A and B
instance at the same time, so you're right about that.

So that's where we come into the implementation specifics.


Cfr above: i don't know that i should go to a C until i got an A
first, because the A class contains some class specific definitions.

Now do i understand it right that the problem comes from the fact that
i'm using a void* ?

Would this be legal then:

// quick recap: class C is derived from both class A and B

A *ap;
B *bp;
C c,*cp;

cp=&c;
ap=cp;
bp=(B*)ap;

Casting an A* into a B*. Bad. A & B are unrelated.

or the last line being

bp=static_cast<B*>(ap);

which is the same, right?

Nope. Compiler should complain about that since A and B are unrelated.

 

[Andre Kostur]

[snip]

I understand that a dynamic_cast cannot do a base-to-derived
conversion, so that's not the solution here.

No, that's exactly what dynamic_cast is for, _if_ the pointer is pointing
to an object that actually is of the derived type.

And a static_cast doesn't seem to make any difference, because i'm
already doing static casts right, just in the 'old' way.

So i'm still looking for the solution for this situation

class A {

public:
virtual long GetClassID() { return(' A'); }
};


class B {

public:
// some class data & funx
};

class C : public class A, public class B {

public:
virtual long GetClassID() { return(' C'); }
};


foo1(C *cp) {
...
foo2(cp);
...
}

foo2(A *ap) {

if (ap->GetClassID==' C') {
C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++
?
}
}

In theory that would work... of course so would:

class A {
virtual ~A() {};
};

class B {
virtual ~B() {};
};

class C : public class A, public class B {
virtual ~C() {};

void cfn() {};
};

foo1(C *cp) {
fooA(cp);
}

fooA(A *ap) {
C * cp = dynamic_cast<C*>(ap);

if (cp != NULL) {
cp->cfn();
}
}



No "getclassid" function required. However, note that there's no mention
of B anywhere in there (other than the inheritance).... so how does B
get involved in this question?

 

[Jo]

Jo wrote:



In the OP you tried to get a B* from a void*. A void pointer is everything
and nothing, the compiler cannot know what type of object it points to.

OK, understood.

So avoid void*. Avoid c-style cast, too. With C++ style cast, the compiler
can warn you whats wrong using them.

OK, will take this into account.

When it's a language thing, it is on-topic.

The point was: When C is derived from A and B, then C is an A and C is a
B at the same time.

I would have been surprised if C++/the compiler would not be able to do
the up/down casts in this family, even when multiple inheritance is into
play.

(i immediately thought of a system how this would be no problem)

For a moment, i thought John said that C is not a B. But i
misunderstood. Now i understand he said that the void* p is not pointing
to the B object (in the given example) which is right because it's a void*.

If the C++ compiler can figure out the A/B/C up/down casts, then of
course i keep on being a happy C++ -er.

I know all this is pure essential.
I'm a bit amazed/ashamed that i ran into this problem (i.e. using the
void*).
I didn't know that when using a void*, you explicitly abandon all type
info, except for the source type.

dynamic_cast can, and is exactly the right tool, to do base-to-derived
conversion. It's like static_cast with an explicit runtime type check.

I understand.

So i'm still looking for the solution for this situation

class A {

public:
virtual long GetClassID() { return(' A'); }
};

[...]


class C : public class A, public class B {

public:
virtual long GetClassID() { return(' C'); }
};


foo1(C *cp) {
...
foo2(cp);
...
}

foo2(A *ap) {

if (ap->GetClassID==' C') {
C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ?
}
}

When you know that an A* points to a C object, you can static_cast it to a
C*. But why inventing your own RTTI? You can use typeid and dynamic_cast
instead.

It's indeed about having a 'little private' RTTI system.

I would like to not use RTTI because i heard about the overhead it brings.

Not sure if that is memory or cpu overhead, or both?

The application i'm working on is a multi-threaded realtime application
where part of the code runs at interrupt level.

And that code must be fast, and may not do any dynamic memory allocs!

So that's why i want to play it safe.

 

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

I got that from http://www.cplusplus.com/doc/tutorial/typecasting.html

But i was just reading another webpage where they indeed use
base-to-derived dynamic casts...

Did i misunderstand the cplusplus page?

Yes, it seems to me like they perform a base to derived cast there
(second example), though their example are perhaps a bit more
complicated than needed.

 

[MUTOOLS]

Andre Kostur wrote:

[snip example. Important point: There is a class C which inherits from A
& B. A & B are otherwise unrelated]

I see.

if... ?

If i wouldn't use that void*

Sure... within the constraints of the language. Means you can pass a C
to something that takes an A, or to something that takes a B. But you
went and removed all type data from the object when it became a void*.
You need to get that pointer back onto the right track first.

Yes, using the void* was the very error.

Casting an A* into a B*. Bad. A & B are unrelated.

Indeed, i fully understand now.

And this also is a nice example why using static_cast is better because

bp=(B*)ap; // just works

 

[Jo]

John Harrison wrote:

Jo wrote:

[snip]

Perhaps you are expecting an ordinary cast to work like a
dynamic_cast? When you write

bp2=(B*)p; // resulting bp2 is WRONG!

you are expecting the program to 'discover' that there a B object
hidden inside the object that p is pointing to?

If so google for dynamic_cast, or better still read a good book.

I understand that a dynamic_cast cannot do a base-to-derived
conversion, so that's not the solution here.

No, that's exactly what dynamic_cast is for, _if_ the pointer is pointing
to an object that actually is of the derived type.

And a static_cast doesn't seem to make any difference, because i'm
already doing static casts right, just in the 'old' way.

So i'm still looking for the solution for this situation

class A {

public:
virtual long GetClassID() { return(' A'); }
};


class B {

public:
// some class data & funx
};

class C : public class A, public class B {

public:
virtual long GetClassID() { return(' C'); }
};


foo1(C *cp) {
...
foo2(cp);
...
}

foo2(A *ap) {

if (ap->GetClassID==' C') {
C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++
?
}
}

In theory that would work... of course so would:

class A {
virtual ~A() {};
};

class B {
virtual ~B() {};
};

class C : public class A, public class B {
virtual ~C() {};

void cfn() {};
};

foo1(C *cp) {
fooA(cp);
}

fooA(A *ap) {
C * cp = dynamic_cast<C*>(ap);

if (cp != NULL) {
cp->cfn();
}
}



No "getclassid" function required.

Indeed.

But i prefer not to use RTTI for the reasons mentioned in the earlier post.

However, note that there's no mention
of B anywhere in there (other than the inheritance).... so how does B
get involved in this question?

I guess i was confused:

Because i ran into the casting problem (due to the use of the void*), i
started thinking that it had to do with the multiple inheritance...

I really didn't know that using a void* abandons all the class relation
info. (and that after all these years of programming, damn damn damn)

Thanks a lot for your help!

A dummy got a bit less dummy