Shared_ptr и парадигма CoW

#include <iostream>
#include "datahandler.h"
 
using namespace std;
 
DataHandler::DataHandler(const DataHandler &h)
{
    if (data == h.data)
        return;
    if (h.data == nullptr)
        return;
    if (h.refCounter == nullptr)
        return;
 
    (*h.refCounter)--;
 
    if((*h.refCounter) == 0)
    {
        delete h.refCounter;
        delete h.data;
    }
 
    data = h.data;
    refCounter = h.refCounter;
    (*refCounter)++;
}
 
DataHandler::~DataHandler()
{
    if (refCounter == nullptr)
        return;
 
    (refCounter)--;
 
    if((*refCounter) == 0)
    {
        delete refCounter;
        delete data;
    }
    refCounter = 0;
    data = 0;
}
 
Data* DataHandler::operator ->()
{
    return data;
}
 
const Data* DataHandler::operator ->() const
{
    ensureInitialized();
    return data;
}
 
void DataHandler::ensureInitialized() const
{
    if (data == nullptr)
    {
 
        Data temp;
        *data = temp;
    }
}

#ifndef DATAHANDLER_H
#define DATAHANDLER_H
 
#include <iostream>
 
using namespace std;
 
// Отвечает за хранение, создание и удаление наших ресурсов.
// Указатель на выделенный буфер, размер строки и тд. - все тут.
class Data
{
public:
    Data() {cout << "Data created\n";} // выделяем память
    Data(const Data&) {cout << "Data copied\n";} // делаем полную копию
    ~Data() {cout << "Data deleted\n";} // подчищаем
 
    void read() const {cout << "Data read() \n";}
    void write() {cout << "Data write() \n";}
};
 
// Отвечает за разделение ресурсов и ленивую инициализацию.
class DataHandler
{
public:
    DataHandler() = default;
    // Если у h есть данные, привязываемся к ним,
    // не забываем про счетчик ссылок. Можно еще по аналогии оператор "="
    // перегрузить.
    DataHandler(const DataHandler &h);
    // Если держим данные, уменьшаем счетчик ссылок, если больше никто на
    // эти данные не ссылается - удаляем.
    ~DataHandler();
 
    // Убеждаемся, что данные есть и спокойно возвращаем.
    const Data *operator ->() const;
    // Убеждаемся, что данные уникальны и спокойно возвращаем.
    Data *operator ->();
 
private:
    mutable int *refCounter; // указатель на счетчик ссылок
    mutable Data *data = nullptr;
 
    // Проверяем, держим ли мы данные, если нет - создаем.
    void ensureInitialized() const;
    // Проверяем, что на эти данные (если они вообще есть) никто кроме
    // нас не ссылается, если нет - создаем себе копию.
    void ensureUnique();
};
 
#endif

#include <iostream>
 
#include "datahandler.h"
 
using namespace std;
 
// Пример использования нашего умного DataHandler`a в другом
// классе. У вас его будет использовать MyString.
class DataUser 
{
public:
    void read() const {dataHandler->read();}
    void write() {dataHandler->write();}
 
private:
    DataHandler dataHandler;
};
 
int main()
{
    // Ничего не происходит, у нас же ленивая инициализация.
    DataUser du1; 
    
    // Создали данные и обратились к ним на чтение.
    du1.read(); 
    
    // Привязываемся к созданным данным.
    DataUser du2(du1);
    
    // Новые данные не создаются, т. к. обращение на чтение.
    du2.read();
 
    // Идет обращение на запись, поэтому сначала создаем себе
    // копию.
    du2.write();
}
 
// Вывод:
// Data created
// Data read() 
// Data read() 
// Data copied
// Data write() 
// Data deleted
// Data deleted

while(*charPointerToCStr++)*charPointerToCStr='A' ;//каждый раз в другое место...