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,*cp 3;
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

[Pete Becker]

Jo wrote:

>
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]

Jo wrote:

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.

>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.

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.

--
Thomas
http://www.netmeister.org/news/learn2quote.html

[Jo]

John Harrison wrote:

>

>>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.

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]

Pete Becker wrote:

Jo wrote:

>>
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.

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]

Jo <jo*******@tele net.bewrote in
news:XV******** *************@p hobos.telenet-ops.be:

Andre Kostur wrote:

>>Jo <jo*******@tele net.bewrote in
news:be****** *************** @phobos.telenet-ops.be:

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

>>>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

if... ?

>>>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.

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.

>>>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.

<Implementati on-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;

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]

Jo <jo*******@tele net.bewrote in
news:fa******** *************@p hobos.telenet-ops.be:

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. 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]

Thomas J. Gritzan wrote:

>Jo wrote:

>>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.

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.

>>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.

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.

>>>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.

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?=]

On 2007-06-18 22:17, Jo wrote:

John Harrison wrote:

>>

>>>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.

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?

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.

--
Erik Wikström

[MUTOOLS]

Andre Kostur wrote:

>Jo <jo*******@tele net.bewrote in
news:XV******* **************@ phobos.telenet-ops.be:

>>Andre Kostur wrote:

>>>Jo <jo*******@tele net.bewrote in
news:be***** *************** *@phobos.telene t-ops.be:

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

I see.

>>>>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

if... ?

If i wouldn't use that void*

>>>>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.

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.

Yes, using the void* was the very error.

>>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.

>>>>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.

<Implementat ion-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
effectivel y 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;

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
bp=static_cast< B*>(ap); // compiler error which is a good thing

>>or the last line being

bp=static_cas t<B*>(ap);

which is the same, right?

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

--

http://www.mutools.com

[Jo]

Andre Kostur wrote:

>Jo <jo*******@tele net.bewrote in
news:fa******* **************@ phobos.telenet-ops.be:

>>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 :)