allocator, при компиляции ошибка - C++ - Ответ 4919875

    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& val=T())                            // Конструктор, который веделяет память на n объектов типа T
         {
             create(n, val);
         }
 
         size_type size() const                                                 // Функция определяющая размер вектора
         {
             return avail-data;
         }
 
         T& operator[](size_type i)                                             // Доступ к i-ому элементу
         {
             return data[i];
         }
         const T& operator[](size_type i) const
         {
             return data[i];
         }
 
         iterator begin()                                                       // Возвращает итератор на начало вектора
         {
             return data;
         }
         const_iterator begin() const
         {
             return data;
         }
         iterator end()                                                         // Возвращает итератор на конец вектора
         {
             return avail;
         }
         const_iterator end() const
         {
             return avail;
         }
 
         Vec(const Vec& v)                                                      // Конструктор копирования         
         {
             create(v.begin(), v.end());
         }
 
         Vec& operator=(const Vec&);                                            // Конструктор присваивания
 
         ~Vec()                                                                 // Деструктор для разрушения вектора
         {
             uncreate();                                                    
         }
 
         void push_back(const T& t)
         {
             if(avail==limit)
                 grow();
             unchecked_append(t);
         }
 
    private:
        iterator data;                                                          // Начало инициализированых элементов
        iterator avail;                                                         // Конец инициализированых элементов и начало неицилизированых
        iterator limit;                                                         // Конец неинициализированых элементов
        
        allocator<T> alloc;                                                     // Объект, управляющий выделением памяти
 
        // Средства размещения в памяти базового массива и его инициализации
        void create();                                                          // Создает пустой vector - объект
        void create(size_type, const T&);                                       // Выделяет кол-во памяти и инициализирует эти элементы
        void create(const_iterator, const_iterator);                            // Работает как две предыдущие
 
        // Средства разрушения элементов массива и освобождения памяти
        void uncreate();
 
        // Вспомогающие процедуры для push_back
        void grow();                                                            // Выделение памяти для хранения хотя бы еще одного элемента
        void unchecked_append(const T&);                                        // Создает элемент в первой ячейки памяти расположенной за уже созданной
    };
 
//------------------------------------
 
    template <class T>                                                          // Cоздаем пустой вектор
    void Vec<T>::create()
    {
        data=avail=limit=0;                                     // Вектор пуст
    }
 
//------------------------------------
 
    template <class T> 
    void Vec<T>::create(size_type n, const T& val)                              // Выделяет памяти на n элементов типа val
    {
        data=alloc.llocate(n);                                  // Выделяется кол-во памяти для хранения n элементов
        limit=avail=data+n;
        uninitialized_fill(data, limit, val);                   // Инициализация всех элементов вектора длинною n
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::create(const_iterator i, const_iterator j)                     // Выделение памяти и инициализация элементов
    {
        data=alloc.allocate(j-i);                               // Выделяет кол-во памяти для хранения j-i элементов 
        limit=avail=uninitialized_copy(i, j, data);             // Инициализация элементов с i по j(посредством копирования), возвращает итератор на элемент за j
    }
 
//-------------------------------------
 
    template <class T> 
    void Vec<T>::uncreate()                                                     // Уничтожает последствия работы функция create
    {
        if (data)
        {
            iterator it=limit;
            while(it!=data)
                alloc.destroy(--it);                            // Разрушаем каждый элемент по очереди
            alloc.deallocate(data, limit-data);                 // Освобождаем всю занятую ранее память
        }
        data=avail=limit=0;                                     // Говорим о том, что вектор пуст
    }
 
//--------------------------------------
 
    template <class T> 
    void Vec<T>::grow()                                                         // Выделение памяти для последуещего элемента
    {
        size_type new_size=max(2*(limit-data), ptrdiff_t(1));   // При увеличении объекта выделяемой области памяти, вдвое большую используемой в данный момент
                                                                // ptrdiff_t(1) - имеет тот же тип, что и limit-data
 
        iterator new_data=alloc.allocate(new_size);             // Веделяем память для хранения 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)                                 // Создание элемента в первой ячейке памяти за уже существующей
    {
        allос.construct(avail++, val);                            // Создание элемента на место avail++ типа val
    }