Array C++

array.cpp

#include <iostream>

#define BLOCK 2048

template <class T>
class Array {
  private:
    T *data;
    size_t cap;
    size_t max_cap;
    void size_data(size_t new_size) {
      T *temp = new T[new_size];
      std::copy(data, data + max_cap, temp);
      max_cap = new_size;
      delete[] data;
      data = temp;
    }
  public:
    Array() {
      cap = 0;
      max_cap = BLOCK;
      data = new T[max_cap];
    }
    Array(size_t c, T v) {
      data = new T[c + BLOCK];
      std::fill(data, data + c, v);
      cap = c;
      max_cap = c + BLOCK;
    }

    ~Array() { delete[] data; }

    typedef T *iterator;
    const iterator begin() {
      return &data[0];
    }
    const iterator end() {
      return &data[cap];
    }

    const void push(T n);
    const void pop();
    const void pop(size_t i);
    const void shift();
    const void unshift(T n);
    const void print();
    const size_t size();

    T& back();
    T& front();
    T& at(size_t i);
    T& operator[](size_t i);
};

template <class T>
const void Array<T>::push(T n) {
  if (cap + 1 >= max_cap) {
    size_data(max_cap + BLOCK);
  }
  data[cap] = n;
  cap++;
}

template <class T>
const void Array<T>::pop() {
  if (cap > 0) {
    cap--;
  }
}

template <class T>
const void Array<T>::pop(size_t i) {
  if (i < 0 || i >= cap || cap == 0) {
    return;
  }
  T *temp = new T[max_cap];
  std::copy(data, data + i, temp);
  std::copy(data + i + 1, data + cap, temp + i);
  cap--;
  delete[] data;
  data = temp;
}

template<class T>
const void Array<T>::shift() {
  if (cap <= 0) {
    return;
  }
  T *temp = new T[max_cap];
  std::copy(data + 1, data + max_cap, temp);
  cap--;
  delete[] data;
  data = temp;
}

template <class T>
const void Array<T>::unshift(T n) {
  if (cap + 1 >= max_cap) {
    size_data(max_cap + BLOCK);
  }
  T *temp = new T[max_cap];
  temp[0] = n;
  std::copy(data, data + cap, temp + 1);
  cap++;
  delete[] data;
  data = temp;
}

template <class T>
const void Array<T>::print() {
  std::cout << "[";
  if (cap != 0) {
    for (int i = 0; i < cap - 1; i++) {
      std::cout << data[i] << ",";
    }
    std::cout << data[cap - 1];
  }
  std::cout << "]\n";
}

template <class T>
const size_t Array<T>::size() {
  return cap;
}

template <class T>
T& Array<T>::operator[](size_t i) {
  return data[i];
}

template <class T>
T& Array<T>::at(size_t i) {
  return data[i];
}

template <class T>
T& Array<T>::back() {
  return data[cap - 1];
}

template <class T>
T& Array<T>::front() {
  return data[0];
}