Легкий вариант реализации класса vector.

#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[] (int n);
 
    const int& operator[] (int n) const;
 
    const int operator= (const int_array& in);
 
    void clear();
 
    void erase(size_t index);
 
    bool empty() const;
 
    int front() const;
 
    int back() const;
};
 
#endif

#include "int_array.h" 
 
int_array::~int_array()
{
    delete [] mas;
}
 
int_array::int_array(size_t n)
{
    if (n < 0)
        return;
 
    mas = new int[n];
    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)
    {
        capacity = size;
        size = n;
    }
    if (size < n)
    {
        int *temp = new int[n];
        capacity = n;
        for (int i = 0; i < size; ++i)
            temp[i] = mas[i];
        for (int i = size; i < n; ++i )
            temp[i] = 0;
        size = n;
        delete []mas;
        mas = temp;
    }
}
 
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;
    else
        std::cout << "Size of massive already null! \n"; 
}
 
int& int_array::operator[] (int n)
{
    if (n < size)
    {
        return mas[n];
    }
    else
        std::cout << "Out of range! \n";
}
 
const int& int_array::operator[] (int n) const
{
    if (n < size)
    {
        return mas[n];
    }
    else
        std::cout << "Out of range! \n";
}
 
const int int_array::operator= (const int_array& in)
{       
    if (&in == this)
        return *this->mas;
    delete [] mas;
    size = in.size;
    capacity = in.capacity;
    mas = new int[capacity];
    for (int i = 0; i < size; ++i)
        mas[i] = in.mas[i];
    return *this->mas;
}
 
void int_array::clear()
{
    size = 0;
    capacity = 1;
}
 
void int_array::erase(size_t index)
{
    int *temp = new int[size-1];
    for (int i = 0; i < index; ++ i)
        temp[i] = mas[i];
    for (int i = index + 1; i < size; ++i)
        temp[i - 1] = mas[i];
    size = size - 1;
    int *t = mas;
    mas = temp;
    delete [] t;
}
 
bool int_array::empty() const
{
    if (size == 0) return true;
    else return false;
}
 
int int_array::front() const
{
    return mas[0];
}
 
int int_array::back() const
{
    return mas[size-1];
}