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

[Bharath]

On Jun 18, 11:17 am, Jo <jo.lan...@tele net.bewrote:

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

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]

Bharath wrote:

>On Jun 18, 11:17 am, Jo <jo.lan...@tele net.bewrote:

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

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

OutputDebugStri ng(cp3->text_a);
OutputDebugStri ng(cp3->text_b);
OutputDebugStri ng(cp3->text_c);

This gives rubbish for text a!!!

Compilation is done with Visual C++ 7.1.3088

[John Harrison]

Jo wrote:

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

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]

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

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

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.

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

[Jo]

Andre Kostur wrote:

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

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

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

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

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.

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

John Harrison wrote:

Jo wrote:

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

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]

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

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