my_class& operator=(const my_class& rhs)
{
   struct{ char data[sizeof(*this)]; } tmp;
   new(&tmp) my_class(rhs); //создаем новый временный экземпляр класса в буфере tmp.
   this->~my_class();//вызываем деструктор на текущем экземпляре.
   memcpy(this, &tmp, sizeof(*this));//бинарно копируем временный экземпляр в текущий.
   return *this;
}

my_class& operator=(const my_class& rhs)
{
   new(this) my_class(rhs); //создаем новый временный экземпляр класса в буфере tmp.
   return *this;
}

my_class& operator=(const my_class& rhs)
{
 struct{ char data[sizeof(*this)]; } tmp;

 new(&tmp) my_class(rhs); //создаем новый временный экземпляр класса в буфере tmp.

 this->~my_class();//вызываем деструктор на текущем экземпляре.
 memcpy(this, &tmp, sizeof(*this));//бинарно копируем временный экземпляр в текущий.
 return *this;
}

void* operator new (size_t sz,size_type data_size)
{
 return ::operator new(sz+data_size);
}

this->my_class::~my_class();

my_class& operator=(const my_class& rhs)
{
   this->my_class::~my_class();
   new(this) my_class(rhs);
   return *this;
}

//
// Make a copy of the context entry.
//
THelpContext::THelpContext(const THelpContext& other)
{
  *this = other;
}

//
// Make a copy of the context entry.
//
THelpContext&
THelpContext::operator =(const THelpContext& other)
{
  HelpFileContextId = other.GetHelpFileContextId();
...

COleSafeArray::COleSafeArray(const COleSafeArray& saSrc)
{
    AfxSafeArrayInit(this);
    *this = saSrc;
    m_dwDims = GetDim();
    m_dwElementSize = GetElemSize();
}

template<class T>
class ReferencePointerBase
{
public:
    T& operator*() { return *_pt; }
    const T& operator*() const { return *_pt; }

    T* operator->() { return _pt; }
    const T* operator->() const { return _pt; }

    T* get() const { return _pt; }

    bool operator!() const { return !_pt; }

protected:
    ReferencePointerBase(T* t = 0) : _pt(t) { Increment(); }
    ReferencePointerBase(const ReferencePointerBase& p) : _pt(p._pt) { Increment(); }
    template<class U> ReferencePointerBase(const ReferencePointerBase<U>& p) : _pt(p._pt) { Increment(); }

    ReferencePointerBase& operator=(T* t) { ReferencePointerBase(t).Swap(*this); return *this; }
    ReferencePointerBase& operator=(const ReferencePointerBase& p) { ReferencePointerBase(p).Swap(*this); return *this; }
    template<class U> ReferencePointerBase& operator=(const ReferencePointerBase<U>& p) { ReferencePointerBase(p).Swap(*this); return *this; }

    ~ReferencePointerBase() { if (_pt) { _pt->Release(); _pt = 0; } }

    friend class ReferencePointerBase;
    template<class U> Swap(ReferencePointerBase<U>& p) { std::swap(_pt, p._pt); }
    void Increment() { if (_pt) _pt->AddRef(); }
    T* _pt;
};

kmn>my_class& operator=(const my_class& rhs)
kmn>{
kmn>   this->my_class::~my_class();
kmn>   new(this) my_class(rhs);
kmn>   return *this;
kmn>}
kmn>

my_class& operator=(const my_class& rhs)
{
   this->my_class::~my_class();
   try {
      new(this) my_class(rhs);
   }catch(...){
      new(this) my_class();//вот здесь try/catch не надо.
         //лучше поиметь unexpected() сразу, чем удаление 
         //непроинициализированного обьекта потом. 
      throw;
   }
   return *this;
}

Problem #1: It Can Slice Objects
Problem #2: It's Not Exception-Safe
Problem #3: It's Inefficient for Assignment
Problem #4: It Changes Normal Object Lifetimes
Problem #5: It Can Still Break Derived Classes
Problem #6: It Relies on Unreliable Pointer Comparisons (но этого у тебя нет)

2) alignment requirements my_class в массиве char, определенном "на стеке", могут не соблюдаться. Undefined behavior.