Thread: Two questions I couldn't answer

So a Co-worker of mine asked me a question I couldn't give a clear answer to.

let's say I have a class A. now, in some function I get A parameter as a reference . in this function body, I inherit from A, add only member function, and static cast A to the derived class and use it this way.
is this safe by the standard? I coudn't agree with myself. logically speaking, I didn't see any reason why it wouldn't work or be unsafe. but it's still very ugly technique.. what does the standard say about it?

second question I had in mind:
we always try to decrease code lines which are repeating themself.
the duplicity between copy constructor and copy assg. operator (and move c.tor + move assg. operator) always seemed redundand and strange. there must be a better way than writing almost the same code twice.
then I thought : why not using placement new on this?
like this :

Code:

A& operator = (const A& rhs){
   new (this) A(rhs);
   return *this;
}

I wonder why this way has never being used before, the STL uses some variation of this snippet to copy/move objects from one container to another..

As for the second question, the difference between operator = and a copy constructors is that in the assignment operator, the object is already constructed. It is a valid, existing object. Therefore, the operator = must tear down the current state and then copy over the other object's state, so it is not equivalent to the copy constructor and so you shouldn't treat them the same.

ok, so what if we have "destruct" function that the destructor calls but also the assg. operator before using the placement new?

about the first, I meant something like this:

Code:

class A{
protected:
  int x;
public:  
A(){ x= 9; }
}

void f (A& a){
 struct B : public A{
void print () {  cout<<x; }
};

B& b = static_cast<B&>(a); //reinterpret_cast?
b.print();

}

you convinced me on the first.

about the second, I'm just thinking logically:
usually , the compiler breaks down a class to C-struct + the methods that are now global and also accepts 'this' pointer.
so

Code:

class Car{
  int dist;
  drive();
};

becomes (after processing)

Code:

struct Car{
int dist;
}

drive(Car* this);

now, B doesn't add any size to A , and anyway, B is driven from A, so you can upcast B* to A*,
so eventually , what you get is

Code:

void print (B* this){
  std::cout<<((A*)this))->x;
}

which is not so bad, because B is in fact A. the only problem that may arise is with the static_cast (or reinterprect_cast). so we're downcasting only to up-cast later, and anyway, the memory address stays the same..

So it's UB. ok, I see.
thanks.