Класс вектор

#ifndef VECTOR_H
#define VECTOR_H
 
 
#pragma once
 
//#include "stdafx.h"
 
namespace external 
{
    typedef unsigned short int uint;
 
    template <typename T> 
    class vector
    {
        
    protected:
        T*                  arr;
        uint                _capacity,
                            _size;
 
        enum Flag           {Dec, Inc};
        bool                resize(Flag);
        /*Увеличивает или уменьшает ёмкость вдвоё*/
 
    public:
        virtual class iterator;
        //virtual class exeption;
         
 
        vector();
        vector(const vector<T>&);
 
        virtual ~vector();
 
        T&                  operator[](const uint&);
        /*Индексирование*/
 
        bool                operator=(const vector<T>&);
        /*Присваивание*/
 
        bool                operator==(/*const*/ vector<T>&); ////!!!!!?????
        /*Сравнение*/
 
        bool                operator!=(/*const*/ vector<T>&);
        /*Сравнение наоборот*/
 
        virtual void        push_back(const T&);
        /*Добавить в конец*/
 
        virtual void        push_front(const T&);
        /*Доавить в начало*/
 
        virtual T           pop_back();
        /*Взять элемент с конца*/
 
        virtual T           pop_front();
        /*Взять элемент с начала*/
 
        virtual void        clear();
        /*Очистка вектора*/
 
        virtual iterator    begin();
        virtual iterator    end();
        /*Итераторы*/
        
        virtual uint        size();
        /*Возвращает размер вектора*/
 
        virtual bool        empty();
        /*Возвращает TRUE если вектор пустой*/
 
        
 
        class iterator 
        {
        protected:
            T*          value;
        public:
            iterator() : value(NULL) {};
 
            iterator(T* val) : value(val) {};
 
            bool    operator++();
            bool    operator--();
            bool    operator++(int);
            bool    operator--(int);
            bool    operator==(const iterator&);
            bool    operator!=(/*const*/ iterator&);
            bool    operator=(const iterator&);
            T       operator*();
 
 
 
        };
 
        /*class OutOfRange
        {
        public:
            OutOfRange();
        };*/
 
 
    };
 
    template <typename T> 
    vector<T>::vector() : _size(0), _capacity(0)
    {
        arr = NULL;
    }
 
    template <typename T> 
    vector<T>::~vector() 
    {
        clear();
    }
 
    template <typename T> 
    void vector<T>::clear() 
    {
        
        _capacity <= 1 ? delete arr : delete[] arr;
        _capacity = _size = 0;
    }
 
    template <typename T> 
    vector<T>::vector(const vector<T> &Q) 
    {
        this->_size = Q._size;
        this->_capacity = Q._capacity;
 
        arr = new T[_capacity];
        for (uint i = 0; i != _size; i++) {
            arr[i] = Q.arr[i];
        }
 
 
    }
 
    template <typename T>
    bool vector<T>::operator =(const vector<T> &Q) 
    {
        this->clear();
        this->_size = Q._size;
        this->_capacity = Q._capacity;
 
        arr = new T[_capacity];
        for (uint i = 0; i != _size; i++) {
            arr[i] = Q.arr[i];
        }
 
        return (true);
    }
 
    template <typename T> 
    void vector<T>::push_back(const T &value) 
    {
        if (  empty()  ) 
        {
            arr = new T(value);
            _capacity = _size = 1;
        }
        else 
        {
            if (  _size == _capacity  ) 
            {
                resize(Flag::Inc);  
            }
            arr[_size] = value;
            _size++;
        }
 
    }
 
    template <typename T>
    void vector<T>::push_front(const T &value)
    {
        // O(n) = n^2 !!!
        if ( empty() )
        {
            arr = new T(value);
            _capacity = _size = 1;
        }
        else
        {
            if (  _size == _capacity  ) 
            {
                resize(Flag::Inc);
            }
            for (uint i = this->size(); i != 0; i--)
            {
                arr[i] = arr[i-1];
            }
            arr[0] = value;
            _size++;
        }
    }
 
    template <typename T>
    T vector<T>::pop_back()
    {
        if (  !_size  )
        {
            throw("Fuck!");
        }
 
        if ( _size == 1 )
        {
            T       tmp = arr[0];
            delete [] arr;
            _size = _capacity = 0;
            return tmp;
 
        }
        
        if (  (_size * 2) < _capacity  )
        {
            resize(Flag::Dec);
        }
 
        _size--;
        
 
        return arr[_size];
    }
 
    template <typename T>
    T vector<T>::pop_front()
    {
        if ( !_size )
        {
            throw("Fuck!");
        }
 
        if ( _size == 1 )
        {
            T       tmp = arr[0];
            delete  [] arr;
            _size = _capacity = 0;
            return tmp;
 
        }
 
        if (  (_size * 2) < _capacity  )
        {
            resize(Flag::Dec);
        }
 
        T tmp(arr[0]);
        for (uint i = 0; i != this->_size; i++)
        {
            arr[i] = arr[i+1];
        }
        _size--;
 
        return tmp;
    }
 
    template <typename T>
    bool vector<T>::operator==(/*const*/ vector<T> &another)
    {
        if ( this->_size == another._size ) 
        {
            for (uint i = 0; i != this->_size; i++)
            {
                if (  (*this)[i] != another[i]  )
                    return false;
            }
        }
        else
        {
            return (false);
        }
 
        return true;
 
    }
 
    template <typename T>
    bool vector<T>::operator!=(/*const*/ vector<T> &another)
    {
        return !(*this == another);
    }
 
    
    template <typename T> 
    T& vector<T>::operator[](const uint &index)
    {
        return arr[index];
    }
 
    template <typename T> 
    bool vector<T>::resize(Flag flag) 
    {
        T* NewArea;
 
        if ( flag == Flag::Inc )
            NewArea = new T[_capacity * 2];
        else
            NewArea = new T[(_capacity / 2) + 1];
        
 
        for (uint i = 0; i != this->_size; i++) 
        {
            NewArea[i] = this->operator[](i);
        }
 
        switch (_capacity)
        {
        case 1: 
            delete arr;
            break;
        case 0: 
            delete arr;
            break;
        default: 
            delete[] arr;
            break;
        }
 
        arr         =    NewArea;
 
        if ( flag == Flag::Inc )
            _capacity   *=   2;
        else
            _capacity = (_capacity / 2) + 1;
        
    
        
 
        return (true);
        
    }
 
    template <typename T>
    uint vector<T>::size()
    {
        return (  _size  );
    }
 
    template <typename T> 
    bool vector<T>::empty() 
    {
        return (  _size == 0  );
    }
 
    template <typename T> 
    typename vector<T>::iterator vector<T>::begin() 
    {
        return (arr);
    }
 
    template <typename T> 
    typename vector<T>::iterator vector<T>::end() 
    {
        return (arr + _size);
    }
        
    template <typename T>
    bool vector<T>::iterator::operator !=(/*const*/ iterator &another)
    {
        return (  value != another.value  );
    }
 
 
    template <typename T> 
    bool vector<T>::iterator::operator--() 
    {
        value--;
        return (true);
    }
 
    template <typename T> 
    bool vector<T>::iterator::operator++() 
    {
        value++;
        return (true);
    }
 
    template <typename T> 
    bool vector<T>::iterator::operator--(int) 
    {
        value--;
        return (true);
    }
 
    template <typename T> 
    bool vector<T>::iterator::operator++(int) 
    {
        value++;
        return (true);
    }
 
    template <typename T> 
    bool vector<T>::iterator::operator==(const iterator &another) 
    {
        return (value == another.value);
    }
 
    template <typename T> 
    bool vector<T>::iterator::operator=(const iterator &another) 
    {
        value = another.value;
        return (true);
    }
 
    template <typename T> 
    T vector<T>::iterator::operator*() 
    {
        return (*value);
    }
 
 
}
 
#endif

virtual class iterator;

                bool                            operator=(const vector<T>&);