Реализация вектора

Vec.h

#ifndef GUARD_Vec
#define GUARD_Vec
#include <memory>
template <class T> class Vec{
 public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef size_t size_type;
    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    Vec() { create(); }
    explicit Vec(size_type n, const T& t = T()) { create(n, t); }
    Vec(const Vec& V) { create(v.begin(), v.end()); }
    Vec& operator=(const Vec&);
    ~Vec() { uncreate(); }
    T& operator[](size_type i) { return data[i]; }
    const T& operator[](size_type i) const { return data[i]; }
    void push_back(const T& t) {
        if(avail == limit)
            grow();
        unchecked_append(t);
    }
    size_type size() const { return avail - data; }
    iterator begin() { return data; }
    const_iterator begin() const { return data; }
    iterator end() { return avail; }
    const_iterator end() const { return avail; }
 private:
    iterator data;
    iterator avail;
    iterator limit;
    std::allocator<T> alloc;
    void create();
    void create(size_type, const T&);
    void create(const_iterator, const_iterator);
    void uncreate();
    void grow();
    void unchecked_append(const T&);
};
#endif

main.cpp

#include <iostream>
#include <locale.h>
#include <iterator>
#include <algorithm>
#include "Vec.h"
using std::cout; using std::cin;
using std::endl; using std::ostream_iterator;
using std::copy; using std::max;
                 using std::uninitialized_copy;
                 using std::uninitialized_fill;

template <class T> void Vec<T>::create() {
    data = avail = limit = nullptr;
}
template <class T> void Vec<T>::create(size_type n, const T& val) {
    data = alloc.allocate(n);
    limit = avail = data + n;
    unitialized_fill(data, limit, val);
}
template <class T> void Vec<T>::create(const_iterator i, const_iterator j) {
    data = alloc.allocate(j - i);
    limit = avail = unitialized_copy(i, j, data);
}
template <class T> void Vec<T>::uncreate() {
    if (data) {
        iterator it = avail;
    while (it != data)
        alloc.destroy(--it);
    alloc.deallocate(data, limit - data);
    }
  data = limit = avail = nullptr;
}
template <class T> void Vec<T>::grow() {
    size_type new_size = max(2*(limit - data), ptrdiff_t(1));
    iterator new_data = alloc.allocate(new_size);
    iterator new_avail = uninitialized_copy(data, avail, new_data);
    uncreate();
    data = new_data;
    avail = new_avail;
    limit = data + new_size;
}
template <class T> void Vec<T>::unchecked_append(const T& val) {
    alloc.construct(avail++, val);
}
template <class T> Vec<T>& Vec<T>::operator=(const Vec& rhs) {
    if (&rhs != this) {
        uncreate();
        create(rhs.begin(), rhs.end());
    }
    return *this;
}

int main(){
    setlocale(LC_ALL,"RUS");
    Vec<int> vec;
    int number;
    cout << "Введите числа: ";
    while(cin >> number)
        vec.push_back(number);
    copy(vec.begin(), vec.end(), ostream_iterator<int>(cout, "\n "));
    return 0;
}

Ошибки

1>main.cpp
1>main.cpp(45): error C3861: unitialized_copy: идентификатор не найден
1>main.cpp(41): note: при компиляции функции-члена "<Нет данных>" класса 
класс <Нет данных>
1>Vec.h(26): note: см. ссылку на создание экземпляров функции шаблон при 
компиляции "void Vec<int>::grow(void)"
1>main.cpp(71): note: см. в справочнике сведения о создании экземпляров 
класса класс шаблон при компиляции "Vec<int>"