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

DataUser::void read() const

void DataHandler::ensureInitialized() const

--(*refCounter);

#include <iostream>
using namespace std;
template<class T>
class CoWptr
{
    public:
      CoWptr()
      :ref_counter(new int(0))
      {}
 
        CoWptr(const T &rval)
        :ptr(new T(rval))
        ,ref_counter(new int(1))
        {}
 
 
            ~CoWptr()
               {
                   liveGroup();
               }
 
              const T & readData()
               {
                   return ((const CoWptr*)this)-> operator*() ;
               }
 
               T & writeData()
               {
                   return this-> operator*() ;
               }
 
            const T * readPtr()
               {
                   return ((const CoWptr*)this)-> operator->() ;
               }
 
               T * writePtr()
               {
                   return this-> operator->() ;
               }
 
        private:
               T& operator*(){ return *ptr ;}
               const T& operator*()const{cout<<" operator*()"; return *ptr ;}
               T* operator->(){return ptr ;}
               const T* operator->()const{cout<<" operator->()"; return ptr ;}
 
 
    void liveGroup()//это вызывать на методах записи - не реализовал т.к. цель - заставить монстрягу реагировать на запись и чтение вызовом разных функций. Что вобщем-то оказалось излишне
               {
                   if(*ref_counter<2 && ptr)
                    delete ptr ;
                   else --*ref_counter ;
               }
 
        T* ptr;
        int *ref_counter;
};
 
struct Data
{
    int a=23;
    int getVal()const{return val;}
    void setVal(int v){val=v;}
    private: int val=123;
};
 
 
int main()
{
const Data data;
CoWptr<Data> cowPtr1(data);
 
cout<<cowPtr1.readData().getVal()<<endl;
cowPtr1.writeData().setVal(2345);
cout<<cowPtr1.readData().getVal()<<endl;
 
return 0;
}

version_ptr<data> smart = make_version_ptr(args...);
 
const data& cur1 = smart.rd(); // <--- тоступ для чтения. 
data& cur2 = smart.wr(); // <--- тоступ для модификации.