static_cast confusion

[buds]

Hi all,

Following is the assigment operator of a derived class

Derived& Derived::operator=(const Derived& inDerived)
{
//to assign to the base class object the following statement

static_cast<Base&>(*this)=inDerived;//works fine

static_cast<Base> (*this)=inDerived;//calls the base class copy constructor.

*((Base*)this) = inDerived;//works fine

return (*this);
}

I thought the static_cast was equivalent to the C-style cast.
Then why this behavior. Can anyone please help me with this

TIA
Buds

[Rolf Magnus]

buds wrote:

Hi all,

Following is the assigment operator of a derived class

Derived& Derived::operator=(const Derived& inDerived)
{
//to assign to the base class object the following statement

static_cast<Base&>(*this)=inDerived;//works fine
This invokes the base class's assignment operator.
static_cast<Base> (*this)=inDerived;//calls the base class copy
constructor.
Right.

*((Base*)this) = inDerived;//works fine
With this, you tell the compiler "hey, I know that 'this' is a pointer
to Derived, but that's not really true. Actually it's a Base, so treat
the pointer as if it were a Base.". It's equivalent to:

*reinterpret_cast<Base*>(this) = inDerived;//works fine

Don't expect that to work generally.

return (*this);
}

I thought the static_cast was equivalent to the C-style cast.

No. The C style cast is equivalent to any combination of static_cast,
const_cast and reinterpret_cast that would be needed for the specific
conversion.

[Chandra Shekhar Kumar]

> Derived& Derived::operator=(const Derived& inDerived)

{
//to assign to the base class object the following statement

static_cast<Base&>(*this)=inDerived;//works fine

static_cast<Base> (*this)=inDerived;//calls the base class copy constructor.
coz, static_cast<Base> results into creation of a temporary obj of type Base


*((Base*)this) = inDerived;//works fine
this is same as *(static_cast<Base*>(this)) = inDerived;


return (*this);
}

I thought the static_cast was equivalent to the C-style cast.

yes, u r right, see the above. but ideally u shud use dynamic_cast for
polymorphic classes..

[Rolf Magnus]

Chandra Shekhar Kumar wrote:

Derived& Derived::operator=(const Derived& inDerived)
{
//to assign to the base class object the following statement

static_cast<Base&>(*this)=inDerived;//works fine

static_cast<Base> (*this)=inDerived;//calls the base class copy
constructor.

coz, static_cast<Base> results into creation of a temporary obj of
type Base

*((Base*)this) = inDerived;//works fine

this is same as *(static_cast<Base*>(this)) = inDerived;

Hmm. I guess I was wrong then.

return (*this);
}

I thought the static_cast was equivalent to the C-style cast.

yes, u r right, see the above. but ideally u shud use dynamic_cast for
polymorphic classes..

Why? You need dynamic_cast to cast from base to derived, not the other
way round.

[Ron Natalie]

"buds" <bu**@ziplip.com> wrote in message news:31**************************@posting.google.c om...

static_cast<Base> (*this)=inDerived;//calls the base class copy constructor.
I thought the static_cast was equivalent to the C-style cast.
You are wrong. Some C style casts are NOT the same as static_cast (but it's
immaterial here).
Then why this behavior. Can anyone please help me with this

The base class copy constructor is called because in order to cast Derived
to Base, a temporary Base object is created and that is what is assigned into.

[Ron Natalie]

"Rolf Magnus" <ra******@t-online.de> wrote in message news:bd*************@news.t-online.com...
\

With this, you tell the compiler "hey, I know that 'this' is a pointer
to Derived, but that's not really true. Actually it's a Base, so treat
the pointer as if it were a Base.". It's equivalent to:

*reinterpret_cast<Base*>(this) = inDerived;//works fine

Don't expect that to work generally.

Huh? The C cast should do a static cast here. The cast works generally
provided that Base is a public base class of Derived.

[Rolf Magnus]

Ron Natalie wrote:

"Rolf Magnus" <ra******@t-online.de> wrote in message
news:bd*************@news.t-online.com... \

With this, you tell the compiler "hey, I know that 'this' is a
pointer to Derived, but that's not really true. Actually it's a Base,
so treat the pointer as if it were a Base.". It's equivalent to:

*reinterpret_cast<Base*>(this) = inDerived;//works fine

Don't expect that to work generally.

Huh? The C cast should do a static cast here. The cast works
generally provided that Base is a public base class of Derived.

Yes, I think you're right. Sorry.

[Mirek Fidler]

"buds" <bu**@ziplip.com> píse v diskusním príspevku
news:31**************************@posting.google.c om...

Hi all,

Following is the assigment operator of a derived class

Derived& Derived::operator=(const Derived& inDerived)
{
//to assign to the base class object the following statement

static_cast<Base&>(*this)=inDerived;//works fine

static_cast<Base> (*this)=inDerived;//calls the base class copy constructor.
*((Base*)this) = inDerived;//works fine

return (*this);
}

I thought the static_cast was equivalent to the C-style cast.
Then why this behavior. Can anyone please help me with this

It is. Problem is that second static_cast transforms into

(Base)(*this) = inDerived;

which, following rules for casting is equivalent for

Base(*this) = inDerived;

which means "create temporary object of Base type using Base(const
Base&) copy constructor and use its operator= .

Mirek