Транзакции и умные указатели

#include <locale.h>
#include <iostream>
using namespace std;
 
// класс, над объектами которого выполняются транзакции
template <class T2>
class Balance
{
T2 quantity;
public:
    Balance() : quantity(0) {}
    void set(int quantity) { this->quantity= quantity; } // инициализация объекта
        T2 get() { return quantity; } // возвращается значение объекта
};
 
// класс пополнения и снятия со счёта
template <class T2>
class Manage_balance
{
    T2* currentState; // текущее значение объекта класса
    T2* prevState; // предыдущее значение объекта класса
public:
    
    Manage_balance (): prevState(NULL), currentState(new T2) {}
    Manage_balance(const Manage_balance& obj) : currentState(new T2(*(obj.currentState))), prevState(NULL) {}
    ~Manage_balance() { delete currentState; delete prevState; } // деструктор
    //перегрузка операции присваивания
    Manage_balance& operator=(const Manage_balance& obj)
    {
        if (this != &obj) // проверка на случай obj=obj
        {
            delete currentState; // удаление текущего значения объекта
            currentState = new T2(*(obj.currentState)); // создание и копирование
        }
        return *this;
    }
    //отображение состояний (предыдущего и текущего) объекта
    void show(int account)
    {
        cout << "состояния объекта ";
        if (!account) cout << "до начала транзакции " << endl;
        else cout << "после выполнения транзакции " << endl;
        if (prevState) cout << "prevState = " << prevState->get() << endl;
        // предыдущее состояние
        else cout << "prevState = NULL" << endl;
        cout << "currentState = " << currentState->get() << endl; // текущее состояние
    }
    //метод пополнения счёта
    int top_up(int quantity)
    {
        delete prevState; // удаление предыдущего значения
        prevState = currentState; // текущее становится предыдущим
        currentState = new T2(*prevState); // создание нового значения текущего состояния
        if (!currentState) return 0; // ошибка (необходимо отменить действие)
        currentState->set(currentState->get()+quantity); // изменение состояния объекта
        return 1; // успешное окончание транзакции
    }
    //метод снятия со счёта
    int withdraw(int quantity)
    {
        delete prevState; // удаление предыдущего значения
        prevState = currentState; // текущее становится предыдущим
        currentState = new T2(*prevState); // создание нового значения текущего состояния
        if (!currentState) return 0; // ошибка (необходимо отменить действие)
        currentState->set(currentState->get() - quantity); // изменение состояния объекта
        return 1; // успешное окончание транзакции
    }
    //метод подтверждения (коммита) транзакции
    void commit()
    {
        delete prevState; // удаление предыдущего значения
        prevState = NULL; // предыдущего состояния нет
    }
    //метод отката транзакции
    void delete_()
    {
        if (prevState != NULL) {
            delete currentState; // удаление текущего значения
            currentState = prevState; // предыдущее становится текущим
            prevState = NULL; // предыдущего состояния нет
        }
    }
    T2 get_cur() { return currentState; }
    T2 get_prev() { return prevState; }
    void set_cur(int currentState) { this->currentState = currentState; }
    void set_prev(int prevState) { this->prevState = prevState; }
    //перегрузка операции ->
    T2* operator->()
    {
        return currentState;
    }
};
 
 
// класс поддержки транзакций
template <class T2>
class Statistics
{
    
};
 
// класс поддержки транзакций
template <class T2>
class Treatment
{
    
};
 
 
int main()
{
    setlocale(LC_ALL, "Russian");
    Manage_balance<Balance<int>> firstTransaction;
    firstTransaction->set(100); // начальная инициализация объекта
    firstTransaction.show(0);
 
    cout << "НАЧАЛЬНАЯ ИНИЦИАЛИЗАЦИЯ ПРОШЛА УСПЕШНО" << endl<<endl;
    cout << "ПЕРВАЯ ТРАНЗАКЦИЯ НАЧАТА СО ЗНАЧЕНИЕМ 50" << endl;
 
    if (firstTransaction.top_up(50)) // начало транзакции (изменение объекта)
    {
        firstTransaction.show(1);
        firstTransaction.commit(); // закрепление транзакции
    }
 
    cout << "ПЕРВАЯ ТРАНЗАКЦИЯ ПРОШЛА УСПЕШНО" << endl<<endl;
    firstTransaction.delete_(); // отмена транзакции при ошибке
    cout << "ПЕРВАЯ ТРАНЗАКЦИЯ БЫЛА ОТМЕНЕНА" << endl;
    firstTransaction.show(0);
 
    Manage_balance<Balance<int>> secondTransaction;
 
    cout << endl<<"ВТОРАЯ ТРАНЗАКЦИЯ НАЧАТА CO ЗНАЧЕНИЕМ 30" << endl;
    if (secondTransaction.withdraw(30)) { // начало транзакции (изменение объекта)
        secondTransaction.show(1);
        secondTransaction.commit(); // закрепление транзакции
    }
 
    cout << "ВТОРАЯ ТРАНЗАКЦИЯ ПРОШЛА УСПЕШНО" << endl;
    /*
    firstTransaction.show(0);*/
    return 0;
}

#include <iostream>
#include <locale.h>
using namespace std;
class Employee {// класс, количество объектов которого должно отслеживаться
int age;
string department;
string position;
public:
void setDepartment(string department){
this->department = department;
}
void showDepartment() { cout << "Сотрудник работает в подразделении:" << department << endl; }
void showPosition() { cout << "Сотрудник работает на должности:" <<
position << endl; }
};
template <class T>
struct Status {
T* ptr; // указатель на объект
int counter; // счетчик числа ссылок на объект
};
//Класс умного указателя. Цель умного указателя состоит в подсчете количества ссылок
//через множество умных указателей на один объект
template <class T>
class SmartPointer {
Status<T>* smartPtr;
public:
SmartPointer(T* ptr = 0);
SmartPointer(const SmartPointer&);
~SmartPointer();
SmartPointer& operator=(const SmartPointer&); //перегрузка оператора
=
T* operator->() const; // перегрузка оператора ->
void showCounter() { cout<<smartPtr->counter; }
};
//конструктор умного указателя
template <class T>
SmartPointer<T>::SmartPointer(T* ptr) {
if (!ptr) smartPtr = NULL; // указатель на объект пустой
else {
smartPtr = new Status<T>;
smartPtr->ptr = ptr; // инициализирует объект указателем
smartPtr->counter = 1; // счетчик «прикрепленных» объектов инициализируем единицей
}
}
//конструктор копирования умного указателя
template <class T>
SmartPointer<T>::SmartPointer(const SmartPointer& obj)
:smartPtr(obj.smartPtr) {
if (smartPtr) smartPtr->counter++; // только увеличение числа ссылок
}
//деструктор умного указателя
template <class T>
SmartPointer<T>::~SmartPointer() {
if (smartPtr) {
smartPtr->counter--; // уменьшается число ссылок на объект
if (smartPtr->counter <= 0) { // если число ссылок на объект
меньше либо равно нулю, то уничтожается объект
delete smartPtr->ptr;//ссылка на объект уничтожается
delete smartPtr;
}
}
}
template <class T>
T* SmartPointer<T>::operator->() const {
if (smartPtr) return smartPtr->ptr;
else return NULL;
}
template <class T>
SmartPointer<T>& SmartPointer<T>::operator=(const SmartPointer& obj) {
if (smartPtr) {
smartPtr->counter--; // уменьшаем счетчик «прикрепленных»
объектов
if (smartPtr->counter <= 0) { // если объектов нет, то выполняется освобождается выделенная память
delete smartPtr->ptr;
delete smartPtr;
}
}
smartPtr = obj.smartPtr; // присоединение к новому указателю
if (smartPtr) smartPtr->counter++; // увеличить счетчик «прикрепленных» объектов
return *this;
}
int main() {
setlocale(LC_ALL, "Russian");
SmartPointer<Employee> employeeIT(new Employee);
employeeIT->setDepartment("Отдел аналитики");
employeeIT->showDepartment();
SmartPointer<Employee> employeeAdmin(new Employee);
SmartPointer<Employee> employeeService = employeeIT;
employeeIT.showCounter();
employeeAdmin.showCounter();
employeeService.showCounter();
employeeAdmin = employeeIT;
employeeAdmin.showCounter();
return 0;
//когда область видимости закончится, объект будет удален
}