casting problem with virtuals

[Jaybob66]

Hi all, I have a problem where my derived class is losing its state data. some isolated code is below, the problem manifests itself in CClassD::DoExtras().

CClassA and CClassC exist in our old codebase and CClassB and CClassD are derived for our new variant of the codebase.

thanks for looking

class CClassA
{
	public:
		int dataA;
};


class CClassB : public CClassA
{
	public:
		int dataB;
};

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

class CClassC
{
public:
	void DoSomething(CClassA& ref)
	{
		// blah...
		DoExtras(ref);
	}

	virtual void DoExtras(CClassA& ref)
	{
		// blah
	}
}


class CClassD : public CClassC
{
public:
	void DoSomething(CClassA& ref)
	{
		// blah blah...
		CClassC::DoSomething(ref)
	}
	
	virtual void DoExtras(CClassA& ref)
	{
		CClassB& b = reinterpret_cast<CClassB&>(ref);
		int i = b.data; // ouch! b.data is uninitialised
	}
}

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

void otherCode()
{
	CClassB myB;
	myB.dataB = 99;

	CClassD myD;
	myD.DoSomething(myB);
}

[Peter87]

int i = b.data; // ouch! b.data is uninitialised
Do you mean dataA or dataB?

I think you should be using static_cast instead of reinterpret_cast because reinterpret cast will not handle if CClassA is stored at an later offset in CClassB.

[JLBorges]

In general prefer using a virtual function over a cast down the hierarchy.

If you have to do a down-cast, prefer a dynamic down-cast.

If for some reason, you have to perform a compile-time cast, the right cast in this case is a static_cast<> , not a reinterpret_cast<>

#include <iostream>
#include <typeinfo>

struct A
{
    virtual ~A() {}
    virtual int get_it() const { return i ; }
    int i = 3 ;
};

struct B : A
{
    virtual int get_it() const override { return A::get_it() + j ; }
    int j = 5 ;
};

int foo( const A& a ) { return a.get_it() ; }

int bar( const A& a )
{
    int result = a.i ;

    try
    {
        const B& b = dynamic_cast< const B& >(a) ;
        result += b.j ;
    }
    catch( const std::bad_cast& ) { /* this is not a B */ }

    return result ;
}

int main()
{
    A a ;
    std::cout << foo(a) << ' ' << bar(a) << '\n' ;

    B b ;
    std::cout << foo(b) << ' ' << bar(b) << '\n' ;

}

http://ideone.com/mMvt8Q

[Jaybob66]

static_cast worked great thankyou both.

@Peter87, it was supposed to be dataB

[mutexe]

In general prefer using a virtual function over a cast down the hierarchy.

I couldn't agree more.

[Jaybob66]

Unfortunately CClassB has a virtual dtor() but no virtual methods so dynamic cast fails with a compiler error.


edited "virtual methods"

[JLBorges]

> Unfortunately CClassB has a virtual dtor() but no virtual methods so dynamic cast fails with a compiler error.

A virtual destructor is sufficient to make the class a polymorphic type.

The dynamic down-cast from CClassA gives an error because CClassA is not a polymorphic type. Add a virtual destructor for CClassA and the error will go away.

[Jaybob66]

@JLBorges

my mistake, CClassB has a virtual dtor() but CClassA doesn't and i dont have write access to it.

I guess thats the root of the problem.

it's all working now though :)