Использование оператора размещения-нового и конструктора копирования вместо оператора присваивания

Я обнаружил проблему при использовании стороннего кода, который нельзя изменить. Мне нужно сделать копию члена объекта. Я не могу сделать это строго потому, что у одного из внутренних членов есть частный оператор присваивания. Единственное решение, которое я нашел, сложное, поэтому я хочу спросить вас, видите ли вы какие-либо красные огни, которые могут повлиять на мою программу.

Вот упрощенный код, с которым я имею дело (помните, что я не могу его изменить!):

#include <iostream>
#include <algorithm>

class MBool
{
public:
    MBool() {};
    MBool(const MBool& arg) {}
private:    
    MBool& operator=(const MBool& arg);
};

class InnerContent {
private:
    int* pBuffer;

public: 
    InnerContent() {
        pBuffer = new int[20];
        std::cout << "InnerContent()" << std::endl;
    }

    InnerContent(const InnerContent& otherInnerContent) {
        pBuffer = new int[20];
        std::copy(otherInnerContent.pBuffer, otherInnerContent.pBuffer + 20, pBuffer);
        std::cout << "InnerContent(const InnerContent&)" << std::endl;
    }

    ~InnerContent() {
        std::cout << "~InnerContent()" << std::endl;
        delete [] pBuffer;
        pBuffer = nullptr;
    }

    virtual void someVirtualFunction() {}
};

class Content {
public:
    InnerContent innerContent;
    int someNumber;
    MBool boolVar;

    Content() {
        std::cout << "Content()" << std::endl;
    }
    ~Content() {
        std::cout << "~Content()" << std::endl;
    }
    Content(const Content& otherContent) :
        innerContent(otherContent.innerContent),
        someNumber(otherContent.someNumber),
        boolVar(otherContent.boolVar)
    {
        std::cout << "Content(const Content&)" << std::endl;
    }

    virtual void someVirtualFunction() {}
};

class A {
public: 
    Content content;

    A() { std::cout << "A()" << std::endl; }
    ~A() { std::cout << "~A()" << std::endl; }
};

class B {
public: 
    Content content;

    B() { std::cout << "B()" << std::endl; }
    ~B() { std::cout << "~B()" << std::endl; }
};

И вот что я собираюсь с ним сделать (только этот код можно изменить и расширить):

void copyContent(Content& contentFrom, Content& contentTo) {
    contentTo.~Content();
    new (&contentTo) Content(contentFrom);
};

int main() {
    A a;
    B b;

    // I wish to do this:
    //b.content = a.content;
    // but Content class has no operator= function implemented
    // also I can't use generated assignment operator function because of MBool::operator= is private

    // The only work-around I found is this:

    std::cout << "--- Before copying" << std::endl;
    copyContent(a.content, b.content);
    std::cout << "--- After copying" << std::endl;
}

Мое решение состоит в том, чтобы вызвать деструктор содержимого вручную, чтобы освободить любую динамически выделенную память в содержимом и его внутренних классах. Память в стеке остается нетронутой, поэтому я могу повторно использовать ее с оператором размещения-нового, который вызывает существующий конструктор копирования и делает именно то, что мне нужно. Когда область действия основной функции заканчивается, объект «a» очищается должным образом.

Вывод кода:

InnerContent()
Content()
A()
InnerContent()
Content()
B()
--- Before copying
~Content()
~InnerContent()
InnerContent(const InnerContent&)
Content(const Content&)
--- After copying
~B()
~Content()
~InnerContent()
~A()
~Content()
~InnerContent()

Я не хочу делать свою функцию, которая копирует все поля, потому что этот класс может быть обновлен в новой версии, и может быть дополнительное поле, которое я не буду копировать и, скорее всего, никто не забудет его исправить.

Вопрос. Как вы думаете, может ли это привести к утечке или повреждению памяти? Вы видите проблемы, о которых я не упомянул?