//Array.h
#pragma once
#ifndef ARRAY_H
#define ARRAY_H
#include <fstream>

using namespace std;

template <typename TYPE> struct Array
{
    //поля
private:
    int size, beginData, endData;             //длина, начало и конец массива
    TYPE* data;                               //данные массива
    void create(int mem, int len, int begin); //функция создания массива
public:
    //конструкторы/деструктор
    Array();      //конструктор без параметров
    Array(int n); //конструктор с параметрами
    ~Array();     //деструктор

    //методы
    int length();             //длина массива
    Array& clear();           //очистить массив
    Array& init(int n);       //инициализировать массив
    Array& pushFront(TYPE x); //вставить элемент в начало массива
    Array& pushBack(TYPE x);  //вставить элемент в конец массива
    TYPE popFront();          //взять начальный элемент массива
    TYPE popBack();           //взять конечный элемент массива

    //перегрузка оператора индексирования
    TYPE& operator [] (int i);
};
//конструкторы/деструктор

//конструктор без параметров
template <typename TYPE> Array<TYPE>::Array()
{
    create(1, 0, 0);
}
//конструктор с параметрами
template <typename TYPE> Array<TYPE>::Array(int n)
{
    create(n, n, 0);
}
//деструктор
template <typename TYPE> Array<TYPE>::~Array()
{
    delete[] data;
}

//методы

//длина массива
template <typename TYPE> int Array<TYPE>::length()
{
    return endData - beginData;
}
//создать массив
template <typename TYPE> void Array<TYPE>::create(int mem, int len, int begin)
{
    if (mem < 1) { mem = 1; }
    if (len < 0) { len = 0; }
    size = mem;
    beginData = begin;
    endData = begin + len;
    data = new TYPE[mem];
}
//очистить массив
template <typename TYPE> Array<TYPE>& Array<TYPE>::clear()
{
    delete[] data;
    create(1, 0, 0);
    return *this;
}
//инициализировать массив
template <typename TYPE> Array<TYPE>& Array<TYPE>::init(int n)
{
    delete[] data;
    create(n, n, 0);
    return *this;
}
//вставить элемент в начало массива
template <typename TYPE> Array<TYPE>& Array<TYPE>::pushFront(TYPE x)
{
    if (beginData == 0)
    {
        TYPE* temp = data;
        create(size + length() / 2 + 1, length(), beginData + length() / 2 + 1);
        for (int i = 0; i < length(); ++i)
        {
            data[beginData + i] = temp[i];
        }
        delete[] temp;
    }
    --beginData;
    data[beginData] = x;
    return *this;
}
//вставить элемент в конец массива
template <typename TYPE> Array<TYPE>& Array<TYPE>::pushBack(TYPE x)
{
    if (endData == size)
    {
        TYPE* temp = data;
        create((size + length()) / 2 + 1, length(), beginData);
        for (int i = beginData; i < endData; ++i)
        {
            data[i] = temp[i];
        }
        delete[] temp;
    }
    data[endData] = x;
    ++endData;
    return *this;
}
//взять начальный элемент массива
template <typename TYPE> TYPE Array<TYPE>::popFront()
{
    if (beginData > length())
    {
        TYPE* temp = data;
        int beginTemp = beginData;
        create(size - beginData, length(), 0);
        for (int i = 0; i < length(); ++i)
        {
            data[i] = temp[beginTemp + i];
        }
        delete[] temp;
    }
    if (length() > 0)
    {
        ++beginData;
    }
    return data[beginData - 1];
}
//взять конечный элемент массива
template <typename TYPE> TYPE Array<TYPE>::popBack()
{
    if (size - endData > length())
    {
        TYPE* temp = data;
        int beginTemp = beginData;
        create(endData, length(), beginData);
        for (int i = beginData; i < endData; ++i)
        {
            data[i] = temp[i];
        }
        delete[] temp;
    }
    if (length() > 0)
    {
        --endData;
    }
    return data[endData];
}

//перегрузка оператора индексирования
template <typename TYPE> TYPE& Array<TYPE>::operator[] (int i)
{
    if (i < 0) { i = 0; }
    else if (i >= length()) { i = length() - 1; }
    return data[beginData + i];
}
#endif