Реализовать класс vector

Vector.h
#include <iostream>
#include <cstdlib>
#include <string>
 
namespace task {
 
class vector 
{
public:
    vector();
    vector(std::size_t size);
    vector(const vector &vec);
    ~vector();
 
    vector& operator=(vector vec);
    int& operator[](size_t &index) const;
 
    void push_back(int &&value);
    void insert(const std::size_t &index, int &&value);
    bool pop(const std::size_t &index);
    std::size_t getIndex(const int &value) const;
    void clear();
    
    std::size_t size() const;
    bool empty();
 
private:
    int *_array;
    std::size_t _size;
};
 
class VectorException : public std::exception 
{
    std::string _msg;
public:
    VectorException(const std::string &msg);
    const char *what() const noexcept override;
};
 
} //end namespace task
 
#endif //VECTOR_H

#include "Vector.h"
 
namespace task {
 
vector::vector()
    : _array(nullptr)
    , _size(0)
{
 
}
 
vector::vector(std::size_t size)
    : _array(static_cast<int*>(malloc(size*sizeof(int))))
    , _size(size)
{
 
}
 
vector::vector(const vector &vec)
    : _array(static_cast<int*>(malloc(vec.size()*sizeof(int))))
    , _size(vec.size())
{
    std::copy(vec._array, vec._array + _size, _array);
}
 
vector::~vector()
{
    clear();
}
 
vector& vector::operator=(vector vec)
{
    std::swap(*this, vec);
    return *this;
}
 
int& vector::operator[](std::size_t &index) const
{
    return _array[index];
}
 
void vector::push_back(int &&value)
{
    if (!(_array = static_cast<int*>(realloc(_array, (size()+1)*sizeof(int)))))
        throw VectorException("Memory allocation error");
    _array[_size++] = std::move(value);
}
 
void vector::insert(const std::size_t &index, int &&value)
{
    if (index >= size()) {
        if (!(_array = static_cast<int*>(realloc(_array, (index+1)*sizeof(int)))))
            throw VectorException("Memory allocation error");
        _array[index] = std::move(value);
        _size = index+1;
    } else {
        push_back(std::move(value));
        for(std::size_t i = size()-1; i >= 0; --i) {
            if (index == i) 
                break;
            std::swap(_array[i], _array[i-1]);
        }
    }
}
 
bool vector::pop(const std::size_t &index)
{
    if (index >= size() || empty())
        return false;
    for(std::size_t i = index; i < size()-1; ++i) {
        std::swap(_array[i], _array[i+1]);
    }
    if (!(_array = static_cast<int*>(realloc(_array, (size()-1)*sizeof(int)))))
        throw VectorException("Memory allocation error");
    _size--;
    return true;
}
 
std::size_t vector::getIndex(const int &value) const
{
    for(std::size_t i = 0; i < _size; ++i) {
        if (value == _array[i])
            return i;
    }
    throw VectorException("Item not found");
}
 
void vector::clear()
{
    if (_array) {
        free(_array);
        _array = nullptr;
    }
    _size = 0;
}
 
std::size_t vector::size() const
{
    return _size;
}
 
bool vector::empty()
{
    return _size == 0 ? true : false;
}
 
VectorException::VectorException(const std::string &msg)
    : _msg(msg)
{
 
}
 
const char *VectorException::what() const noexcept
{
    return _msg.c_str();
}
 
} //end namespace task

vector& operator=(const vector &vec);

bool empty() const;