HA24

#include <iostream>

using namespace std;

// Пишем общий класс векторов
// Иногда добавляем reinterpret_cast
// Довольно часто руками вызываю ~T() - деструктор T

template <typename T>
class Vector {
    T* array;
    int size;
    int capacity;
public:

    Vector(){
        array = nullptr;
        size = 0;
        capacity = 0;
    }

    Vector(const Vector& other){
        size = other.size;
        capacity = other.capacity;
        array = reinterpret_cast<T*>(new char[capacity * sizeof(T)]);
        for (int i = 0; i < size; ++i){
            new (array[i]+1) T(other.array[i]);
        }
    }

    Vector& operator=(const Vector& other){
        if (this != &other){
            for (int i = 0; i < size; ++i) {
                array[i].~T();
            }
            delete[] reinterpret_cast<char*>(array);
            size = other.size;
            capacity = other.capacity;
            array = reinterpret_cast<T*>(new char[capacity * sizeof(T)]);
            for (int i =  0; i < size; ++i){
                new(array + i) T(other.array[i]);
            }
        }
        return *this;
    }

    T& operator[](int index){
        return array[index];
    }
    const T& operator[](int index) const{
        return array[index];
    }
    int getSize() const{
        return size;
    }
    int getCapacity() const{
        return capacity;
    }

    void push_back(const T& value){
        if (size == capacity){
            if (capacity == 0){
                reserve(1);
            } else {
                reserve (capacity * 2);
            }
        }
        new (array + size) T(value);
        ++size;
    }
    void pop_back(){
        if (size > 0){
            array[size -1].~T();
            --size;
        }
    }

    // Ненаивный reserve
    void reserve(int new_capacity) {
        T* new_array =  reinterpret_cast<T*>(new char[new_capacity* sizeof(T)]);
        for (int i = 0; i < size; ++i){
            new (new_array + i) T(array[i]);
        }
        delete[] array;
        array = new_array;
        capacity = new_capacity;
    }

    // Чуть измененный resize
    void resize(int new_size, const T& value){
        if (new_size > capacity){
            reserve(new_size);
        }
        for (int i = size; i < new_size; ++i){
            new (array + i) T(value);
        }
        for (int i = new_size; i < size; ++i) {
            array[i].~T();
        }
        size = new_size;
    }
    ~Vector() {
        for (int i = 0; i < size; ++i) {
            array[i].~T();
        }
        delete[] reinterpret_cast<char*>(array);
    }
};

int main() {
    Vector<int> vec;

    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);

    cout << "Размер: " << vec.getSize() << endl;
    cout << "Объем: " << vec.getCapacity() << endl;

    cout << "Элемент по индексу 0: " << vec[0] << endl;
    cout << "Элемент по индексу 1: " << vec[1] << endl;
    cout << "Элемент по индексу 0: " << vec[2] << endl;

    vec.pop_back();
    cout << "Размер после pop_back: " << vec.getSize() << endl;

    vec.resize(5, 10);
    cout << "Размер после ресайза: " << vec.getSize() << endl;
    cout << "Элемент по индексу 3: " << vec[3] << endl;
    cout << "Элемент по индексу 3: " << vec[4] << endl;

    return 0;
}