Re: virtual operator =

Thanks everyone for the links and answers.
I asked because I want to write the advice: "Don't create the virtual
operator =" and I was trying to find out if it could be useful in some
cases.

I believe that for polymorphic objects the best way is to provide the
function Clone() and always to use pointers or references. In this
scenario the "copy" means: destroy and create a new one.

If the objects are the same type verified by typeid we could use the
same memory and the inplace new as an optimization.
I think that is not useful because is too much code and probably one
smart allocator can resolve the optimization problem.
Well I did one experiment for fun.

class base
{
     virtual base * Clone() = 0;
     virtual void ImplaceClone(base *) = 0;

public:

     virtual ~base() {};

     void CopyTo(base *& p)
     {
         // is the same type?
         if (p && typeid(*this) == typeid(*p))
         {
             (*p).~base(); // destroy
             ImplaceClone(p); // utilize the same memory
         }
         else //different
         {
             delete p; //delete
             p = Clone(); // create a new one
         }
     }

};

#define POLYMORPHIC_COPY_IMP(Class)\
     Class * Clone() { return new Class(*this); } \
     void ImplaceClone(base * p) { new (p) Class(*this); }

class derived : public base
{
     POLYMORPHIC_COPY_IMP(derived);

};

class derived2 : public base
{
     POLYMORPHIC_COPY_IMP(derived2);

};

int main()
{
     derived d;
     base *p = 0;
     d.CopyTo(p); // create a copy
     derived d1;
     d1.CopyTo(p); // create a copy using the same memory
     derived2 d2;
     d2.CopyTo(p); // delete and create a copy

}

Advices:
- Don't create the "operator =" for polymorphic types. Provide it for
concrete types.
- For polymorphic types use the Clone function.
- Don't make your code more complicated :)

Everyone agrees with these advices?