deq_imp

#pragma once
#include <initializer_list>
#include <iterator>

template <typename T>
class deque{
public:
    using iterator = std::random_access_iterator_tag;

    // constructor default
    deque(): ptr_deq_(nullptr), deq_start_(0), deq_end_(0), size_deq_(0)
    , size_chunk_(0), chunk_start_(0), chunk_end_(0){}

    deque(const T& elem){
        ptr_deq_ = new T*[BLOCK_SIZE](); // инициализируем  [0][0][0][0][0][0][0][0]
                                                   //        |  |  |  |  |  |  |  |

        ptr_deq_[0] = new T[BLOCK_SIZE];        // инициализируем первый блок чанков 8.
        ptr_deq_[0][0] = elem;     // первый элемент раверн elem

        deq_start_ = 0;
        deq_end_ = 1;
        size_deq_ = 1;
        size_chunk_ = BLOCK_SIZE;
        chunk_start_ = 0;
        chunk_end_ = 1;
    }

    deque(std::initializer_list<T> lst): size_deq_(lst.size())
    , size_chunk_((size_deq_ + BLOCK_SIZE - 1) / BLOCK_SIZE)
    , ptr_deq_(new T*[size_deq_])
    , deq_start_(0)
    , deq_end_(size_deq_)
    {
        for(size_t i = 0; i < size_chunk_; ++i){
            ptr_deq_[i] = new T[BLOCK_SIZE]();
        }

        size_t i = 0;
        for(const auto& elem: lst){
            ptr_deq_[i / BLOCK_SIZE][i % BLOCK_SIZE] = elem;
            ++i;
        }
    }

    ~deque(){
        for(size_t i = 0; i < size_deq_; ++i){
            delete ptr_deq_[i];
        }
        delete[] ptr_deq_;
    }

    // methods
    void push_back(const T& elem);
    void push_front(const T& elem);
    void resize(const size_t sz);

    T& front() {
        return ptr_deq_[deq_start_ / BLOCK_SIZE][deq_start_ % BLOCK_SIZE];
    }

    const T& front() const {
        return ptr_deq_[deq_start_ / BLOCK_SIZE][deq_start_ % BLOCK_SIZE];
    }

    T& back(){
        return ptr_deq_[(deq_end_-1) / BLOCK_SIZE][(deq_end_-1) % BLOCK_SIZE];
    }

    const T& back() const{
        return ptr_deq_[(deq_end_-1) / BLOCK_SIZE][(deq_end_-1) % BLOCK_SIZE];
    }

    size_t size(){
        return size_deq_;
    }


private:
    static const size_t BLOCK_SIZE = 8;
    // Указатель на массив элементов
    T** ptr_deq_;           // * -> |||||
                            // * -> |||||


    size_t deq_start_;      // старт deque
    size_t deq_end_;        // конец deque
    size_t size_deq_;       // размер всего deque


    size_t size_chunk_;     // размер чанка в deque
    size_t chunk_start_;    // начало элементов в массиве * -> |... начало
    size_t chunk_end_;      // конец элементов в массиве * -> ...| конец
};