Усовершенствованный вектор!

#pragma once
#ifndef _INT_ARRAY_
#define _INT_ARRAY_
 
class int_array
{
    int *mas, size, capacity;
public:
    int_array(): mas(0), size(0), capacity(0){};
 
    ~int_array();
 
    explicit int_array(size_t n);
 
    int_array(const int_array& in);
 
    int getSize() const;
 
    int getCapacity() const;
 
    void resize(size_t n);
 
    void reserve(size_t n);
 
    void push_back(int val);
 
    void pop_back();
 
    int& operator[] (size_t n);
 
    const int& operator[] (size_t n) const;
 
    int& int_array::at(size_t n);
 
    int_array& operator= (const int_array& in);
 
    void clear();
 
    void erase(size_t index);
 
    bool empty() const;
 
    int front() const;
 
    int back() const;
 
    int& int_array::front();
 
    int& int_array::back();
 
    void swap (int_array &in) throw ();
};
 
#endif

#include "int_array.h" 
#include <stdexcept>
#include <algorithm> 
 
int_array::~int_array()
{
    delete [] mas;
}
 
int_array::int_array(size_t n)
{
    mas = new int[n];
    for (int i = 0; i < n; ++i)
        mas[i] = 0;
    size = n;
    capacity = n;
}
 
int_array::int_array(const int_array& in)
{
    size = in.size;
    capacity = in.capacity;
    mas = new int[capacity];
    for (int i = 0; i < size; ++i)
        mas[i] = in.mas[i];
}
 
int int_array::getSize() const
{
    return size;
}
 
int int_array::getCapacity() const
{
    return capacity;
}
 
void int_array::reserve(size_t n)
{
    if (n > capacity)
    {
        int *temp = new int[n];
        capacity = n;
        for (int i = 0; i < size; ++i)
            temp[i] = mas[i];
        delete []mas;
        mas = temp;
    }
}
 
void int_array::resize(size_t n)
{
    if (size > n)
    {
        size = n;
        return;
    }
    if (size < n)
    {
        reserve(n);
        for (int i = size; i < n; ++i)
            mas[i] = 0;
    }
}
 
void int_array::push_back(int val)
{
    if (size >= capacity)
    {
        size_t new_size = size + 1;
        reserve(new_size + new_size / 2);
    }
    mas[size++] = val;
}
 
void int_array::pop_back()
{
    if (size >= 1)
        --size;
}
 
int& int_array::operator[] (size_t n)
{
    return mas[n];
}
 
const int& int_array::operator[] (size_t n) const
{
    return mas[n];
}
 
int& int_array::at(size_t n)
{
    if (n >= size)
        throw std::out_of_range("Index out of range!");
    return mas[n];
}
 
int_array& int_array::operator= (const int_array& in)
{
    int_array temp(in);
    temp.swap(*this);
    return *this;
}
 
void int_array::swap(int_array& in)
{
    std::swap(mas, in.mas);
    std::swap(size, in.size);
    std::swap(capacity, in.capacity);
}
 
void int_array::clear()
{
    size = 0;
}
 
void int_array::erase(size_t index)
{
    if (index >= size) 
        throw std::out_of_range("Index out of range!");
    --size;
    for (int i = index; i < size; ++i)
        mas[i] = mas[i + 1];
}
 
bool int_array::empty() const
{
    return size == 0;
}
 
int int_array::front() const
{
    return mas[0];
}
 
int int_array::back() const
{
    return mas[size-1];
}
 
int& int_array::front()
{
    return mas[0];
}
 
int& int_array::back()
{
    return mas[size-1];
}