Создать класс "Вектор" и реализовать конструктор по умолчанию, конструктор копирования и деструктор

#include "stdafx.h"
#include "stdio.h"
#include <time.h> 
#include <stdlib.h>
 
class vector
{  
private:
    int* m;
    int size;
public :
    vector(int n = 0);
    vector(const vector &vector2);
    ~vector();
};
vector::vector( int n )
{   
    if (n < 0) n = 0;
    size = n;
    m = new int[n];
if(!m)
printf("Error");
else
m = NULL;
}
vector::vector(const vector &vector2)
{
    size = vector2.size;
        m = new int [size];
    for(int i = 0; i<size;i++)
        m[i] = vector2.m[i];
    printf("kopia stvorena !");
}
vector::~vector()
{
        delete[] m;
}
vector(int *m, int size)
{
      srand(time(NULL))
          if(!m)
              printf("error")
          else
          for(int i = 0; i < size; i++)
           m[i] = rand()% 99;
}
 
 
int main()
{  
    vector v1(45),
    
 system("pause");
    return 0;
}

vector::vector( int n )
{   
    if (n < 0) n = 0;
        size = n;
    m = new int[n];
    
    if (!m) printf("Error");
    else m = NULL; // Круто вы тут! Получается если память выделили успешно
                 // и указатель ненулевой, так мы сами его обнулим.
}

vector::vector( int n )
{   
    if (n < 0) n = 0; // Будет m = new int[0], так можно, но вы понимаете, зачем так делаете?
        size = n;
    m = new int[n]; // Что произойдет, если new не сможет выделить память? Нужна ли следующая строка?
    if (!m) printf("Error");
}

vector vec1(2);
vector vec2(vec1); // хорошо.
vector vec3 = vec2; // а здесь?

class Array
{
public:
    Array();
    Array(size_t);
    Array(const Array &);
    ~Array();
 
    size_t size() const;
    size_t capacity() const;
 
    void resize(size_t);
 
    void push_back(double);
    void erase(size_t, size_t);
 
    const Array &operator=(const Array &);
 
    const double &operator[](size_t) const;
    double &operator[](size_t);
 
private:
    double *_array;
    size_t _size;
    size_t _capacity;
};
 
Array::Array():
_array(0),
_size(0),
_capacity(0)
{
}
 
Array::Array(size_t size):
_size(size),
_capacity(1)
{
    while (_capacity < _size)
        _capacity *= 2;
 
    _array = new double [_capacity];
}
 
Array::Array(const Array &original):
_size(original._size),
_capacity(original._capacity)
{
    _array = new double [_capacity];
 
    for (size_t i = 0; i < _size; ++i)
        _array[i] = original._array[i];
}
 
Array::~Array()
{
    delete [] _array;
}
 
size_t Array::size() const
{
    return _size;
}
 
size_t Array::capacity() const
{
    return _capacity;
}
 
void Array::resize(size_t new_size)
{
    _capacity = 1;
 
    while (_capacity < new_size)
        _capacity *= 2;
 
    double *new_array = new double [_capacity];
 
    if (_array != 0)
    {
        size_t count = new_size < _size ? new_size : _size;
 
        for (size_t i = 0; i < count; ++i)
            new_array[i] = _array[i];
 
        delete [] _array;
    }
 
    _array = new_array;
    _size = new_size;
}
 
void Array::push_back(double element)
{
    if (_size == _capacity)
    {
        resize(_size + 1);
        --_size;
    }
 
    _array[_size++] = element;
}
 
void Array::erase(size_t begin_index, size_t end_index)
{
    size_t new_capacity = 1;
    size_t new_size = _size - end_index + begin_index + 1;
 
    while (new_capacity < new_size)
        new_capacity *= 2;
 
    double *new_array = new double [new_capacity];
 
    for (size_t i = 0; i <= begin_index; ++i)
        new_array[i] = _array[i];
 
    for (size_t i = begin_index + 1, j = end_index; j < _size; ++i, ++j)
        new_array[i] = _array[j];
 
    delete [] _array;
 
    _size = new_size;
    _capacity = new_capacity;
    _array = new_array;
}
 
const Array &Array::operator=(const Array &rhs)
{
    if (&rhs != this)
    {
        _size = rhs._size;
        _capacity = rhs._capacity;
 
        delete [] _array;
 
        _array = new double [_capacity];
 
        for (size_t i = 0; i < _size; ++i)
            _array[i] = rhs._array[i];
    }
 
    return *this;
}
 
const double &Array::operator[](size_t index) const
{
    return _array[index];
}
 
double &Array::operator[](size_t index)
{
    return _array[index];
}

class Allocator
{
public:
    template<class T1, class T2>
    void construct(T1* p, const T2& value)
    {
        new(p) T1(value);
    }
    template<class T>
    void destroy(T* p)
    {
        p->~T();
    }
    template<class Iter>
    void destroy(Iter first, Iter last)
    {
        while(first != last)
        {
            destroy(*&first);
            ++first;
        }
    }
};
 
template<class T, class Alloc=Allocator>
class Vector_base
{
public:
    Vector_base(T sz=0, Alloc al=Alloc()):arr_(static_cast<T*>(sz == 0 ? 0 :
        operator new(sizeof(T)*sz))), cap_(sz), sz_(sz), al_(al)
    {
    }
    ~Vector_base()
    {
        al_.destroy(arr_, arr_+sz_);
        operator delete(arr_);
    }
    void Swap(Vector_base& other) /*throw()*/
    {
        std::swap(arr_, other.arr_);
        std::swap(sz_, other.sz_);
        std::swap(cap_, other.cap_);
    }
    T* arr_;
    size_t sz_;
    size_t cap_;
    Alloc al_;
private:
    Vector_base(const Vector_base&);
    Vector_base& operator =(const Vector_base&);
};
 
template<class T, class Alloc=Allocator>
class Vector
{
public:
    Vector(size_t sz=0, Alloc al=Alloc()):impl_(sz, al)
    {
    }
    ~Vector()
    {
    }
    Vector(const Vector& other):impl_(other.impl_.cap_)
    {
        while(impl_.sz_ != other.impl_.sz_)
        {
            impl_.al_.construct(impl_.arr_ + impl_.sz_,
                other.impl_.arr_[impl_.sz_]);
            ++impl_.sz_;
        }
    }
    Vector& operator =(const Vector& other)
    {
        Vector temp(other);
        impl_.Swap(temp.impl_);
        return *this;
    }
    const size_t size() const
    {
        return impl_.sz_;
    }
    T& operator [](const size_t idx)
    {
        return *(impl_.arr_+idx);
    }
    const T& operator [](const size_t idx) const
    {
        return *(impl_.arr_+idx);
    }
private:
    Vector_base<T> impl_;
};
 
int main()
{
    const int n=10;
    Vector<int> vec(n);
    for(int i=0; i<n; ++i)
        vec[i]=i+1;
    for(size_t i=0; i<vec.size(); ++i)
        std::cout<<vec[i]<<'\n';
    return 0;
}