Ещё чуть-чуть вектора.

#pragma once
#include <stdexcept>
#include <algorithm> 
 
class IntVector
{
    int *mas;
    size_t size, capacity;
public:
    
    IntVector();
 
    ~IntVector();
 
    IntVector(const IntVector& in);
 
    explicit IntVector(const size_t aSize, const int val = 0);
 
    size_t getSize() const;
 
    size_t getCapacity() const;
 
    void resize(size_t n);
 
    void reserve(size_t n);
 
    void pushBack(int val);
 
    void popBack();
 
    int& operator[] (size_t n);
 
    const int& operator[] (size_t n) const;
 
    int& at(size_t n);
 
    IntVector& operator= (const IntVector& in);
 
    void clear();
 
    void erase(size_t index);
 
    bool empty() const;
 
    int front() const;
 
    int back() const;
 
    int& front();
 
    int& back();
 
    void swap (IntVector &in) throw ();
};

#include "int_array.h" 
 
 
IntVector::~IntVector()
{
    delete [] mas;
}
 
IntVector::IntVector() : mas(0), size(0), capacity(0)
{
}
 
IntVector::IntVector(const IntVector& in)
{
    size = in.size;
    capacity = in.capacity;
    mas = new int[capacity];
    for (int i = 0; i < size; ++i)
        mas[i] = in.mas[i];
}
 
IntVector::IntVector(const size_t aSize, const int val)
{
    mas = new int[aSize];
    size = aSize;
    capacity = aSize;
    for (int i = 0; i < size; ++i)
        mas[i] = val;
}
 
size_t IntVector::getSize() const
{
    return size;
}
 
size_t IntVector::getCapacity() const
{
    return capacity;
}
 
void IntVector::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 IntVector::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 IntVector::pushBack(int val)
{
    if (size >= capacity)
    {
        size_t new_size = size + 1;
        reserve(new_size + new_size / 2);
    }
    mas[size++] = val;
}
 
void IntVector::popBack()
{
    if (size >= 1)
        --size;
}
 
int& IntVector::operator[] (size_t n)
{
    return mas[n];
}
 
const int& IntVector::operator[] (size_t n) const
{
    return mas[n];
}
 
int& IntVector::at(size_t n)
{
    if (n >= size)
        throw std::out_of_range("Index out of range!");
    return mas[n];
}
 
IntVector& IntVector::operator= (const IntVector& in)
{
    IntVector temp(in);
    temp.swap(*this);
    return *this;
}
 
void IntVector::swap(IntVector& in) throw()
{
    std::swap(mas, in.mas);
    std::swap(size, in.size);
    std::swap(capacity, in.capacity);
}
 
void IntVector::clear()
{
    size = 0;
}
 
void IntVector::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 IntVector::empty() const
{
    return size == 0;
}
 
int IntVector::front() const
{
    return mas[0];
}
 
int IntVector::back() const
{
    return mas[size-1];
}
 
int& IntVector::front()
{
    return mas[0];
}
 
int& IntVector::back()
{
    return mas[size-1];
}