Потеря данных при использовании оператора при наследовании

#include <iostream>
#include "cFour.h"
int main()
{
    
    cOne c1("cOne", 2.5);
    std::cout << c1 << std::endl;
 
    cTwo c2(1.2, c1);
    std::cout << c2 << std::endl;
 
    cThree c3(true, c2);
    std::cout << c3 << std::endl;
 
    cFour c4(false, c3);
    std::cout << c4 << std::endl;
 
    return 0;
}

#include <iostream>
class cOne{
    public:
        cOne(); //инициализаця класса без значений
        cOne(const char* ps, float f );//инициализация класса со значениями
        cOne(const cOne& cone);//конструктор копирования
        ~cOne() = default;//деструктор
 
        void setF(float f);//сеттер f
        void setPs(char* ps);//setter ps
 
        double getF()const;//getter f
        const char* getPs()const;//getter ps
 
        void print()const;
 
        cOne& operator=(const cOne& r);
        cOne& operator=(cOne&& r)noexcept;
    private:
        float _f;
        char* _ps;
};
std::ostream& operator<< (std::ostream& out, const cOne& r);

#include "cOne.h"
#include <iostream>
 
cOne::cOne():_f(0.0) {
    _ps = new char[1];
    memcpy(_ps, "\0", 1);
}
cOne::cOne(const char* ps, float f):_f(f) {
    size_t len = strlen(ps) + 1;
    _ps = new char[len];
    memcpy(_ps, ps, len);
}
cOne::cOne(const cOne& cone):_f(cone._f),_ps(cone._ps) {
 
}
void cOne::setF(float f) {
    _f = f;
}
void cOne::setPs(char* ps) {
    _ps = ps;
}
double cOne::getF()const {
    return _f;
}
const char* cOne::getPs()const {
    return _ps;
}
cOne& cOne::operator=(const cOne& r)
{
    _f = r._f;
    _ps = r._ps;
 
    return *this;
}
cOne& cOne::operator=(cOne&& r)noexcept
{
    _f = r._f;
    _ps = std::move(r._ps);
 
    return *this;
}
 
void cOne::print()const{
    std::cout << *this;
}
 
std::ostream& operator<< (std::ostream& out, const cOne& r)
{
    out << "(f:" << r.getF() << " ps:" << r.getPs() << ")";
    return out;
}

#include <iostream>
#include "cOne.h"
class cTwo {
public:
    cTwo(); //инициализаця класса без значений
    cTwo(double d, const cOne& one);//инициализация класса со значениями +cOne
    cTwo(const cTwo& cone);//конструктор копирования
    ~cTwo();//деструктор
 
    void setD(double d);//сеттер ps
    void setOne(const cOne& one);//
 
    const cOne& getOne()const;//getter one
    const double getD()const;//getter d
 
    virtual void print()const;
 
    cTwo& operator=(const cTwo& r);
    cTwo& operator=(cTwo&& r)noexcept;
protected:
    double _d;
    cOne* _one;
};
std::ostream& operator<< (std::ostream& out, const cTwo& r);

#include "cTwo.h"
#include <iostream>
 
cTwo::cTwo() :_one(new cOne),_d(0.0){
 
}
cTwo::cTwo(double d, const cOne& one): _one(new cOne(one)), _d(d){
    //_one = new cOne(one);
}
cTwo::cTwo(const cTwo& cone) : _one(new cOne(*cone._one)), _d(cone._d) {
 
}
cTwo::~cTwo()
{
    delete _one;
}
void cTwo::setOne(const cOne& one) {
    this->_one->~cOne();        //ручной вызов деструктора
    new (this->_one) cOne(one); //ручной вызов конструктора (new память НЕ выделяет)
}
void cTwo::setD(double d) {
    _d = d;
}
const cOne& cTwo::getOne()const {
    return *_one;
}
const double cTwo::getD()const {
    return _d;
}
cTwo& cTwo::operator=(const cTwo& r)
{
    this->_one->~cOne();           //ручной вызов деструктора
    new (this->_one) cOne(*r._one); //ручной вызов конструктора (new память НЕ выделяет)
 
    _d = r._d;
 
    return *this;
}
cTwo& cTwo::operator=(cTwo&& r)noexcept
{
    _one = r._one;
    r._one = nullptr;
    _d = std::move(r._d);
    return *this;
}
 
void cTwo::print()const {
    std::cout << *this;
}
 
std::ostream& operator<< (std::ostream& out, const cTwo& r)
{
    out << "(one:" << r.getOne() << ", ps:" << r.getD() << ")";
    return out;
}

#include <iostream>
#include "cTwo.h"
 
class cThree : public cTwo {
public:
    cThree();
    cThree(const bool on, const cTwo& two);
    cThree(const cThree& n);
    ~cThree();
 
    void setBool3(bool on);
 
    bool getBool3() const;
 
    void print()const override;
 
    cThree& operator=(const cThree& tr);
protected:
    bool _on;
};
std::ostream& operator<< (std::ostream& out, const cThree& tr);

#include "cThree.h"
#include <iostream>
 
cThree::cThree() : _on(true){
 
}
cThree::cThree(const bool on, const cTwo& two) : cTwo(two), _on(on) {
    
}
cThree::cThree(const cThree& n) {
    _on = n._on;
    new cTwo(n);
 
}
cThree::~cThree(){
 
}
 
void cThree::setBool3(bool on) {
    _on = on;
}
bool cThree::getBool3() const {
    return _on;
}
 
cThree& cThree::operator=(const cThree& th){
    _on = th._on;
    cTwo::operator=(th);
 
    return *this;
}
 
void cThree::print() const{
    std::cout << *this;
}
 
std::ostream& operator<< (std::ostream& out, const cThree& th)
{
    out << "(two:" << (cTwo)th << ", ps:" << th.getBool3() << ")";
    return out;
}

#include <iostream>
#include "cThree.h"
 
class cFour : public cThree {
public:
    cFour();
    cFour(const bool off, const cThree& three);
    cFour(const cFour& n4);
    ~cFour();
 
    void setBool4(bool off);
    bool getBool4() const;
    
    virtual void print()const override;
 
    cFour& operator=(const cFour& f);
 
private:
    bool _off;
};
std::ostream& operator<< (std::ostream& out, const cFour& f);

#include "cFour.h"
#include <iostream>
 
cFour::cFour() : _off(false) {
 
}
cFour::cFour(const bool off, const cThree& three) : cThree(three), _off(off) {
 
}
cFour::cFour(const cFour& n4) {
    _off = n4._off;
    new cThree(n4);
}
cFour::~cFour() {
 
}
void cFour::setBool4(bool off) {
    _off = off;
}
bool cFour::getBool4() const {
    return _off;
}
void cFour::print() const {
    std::cout << *this;
}
std::ostream& operator<< (std::ostream& out, const cFour& f)
{
    out << "(three:" << (cThree)f << ", ps:" << f.getBool4() << ")";
    return out;
}