vector v3_pointers

#ifndef MYTEMPLATE_VECTOR
#define MYTEMPLATE_VECTOR

#include <stdexcept>
#include "vector_iterator.h"

namespace mytemplate
{
    template <class T>
    class vector
    {
    private:
        T** array;
        size_t  m_size;
        size_t  m_capacity;

        // oblicza następną potęgę 2 nie mniejszą niż 'number'(może być równa)
        size_t nextGreatestPower( size_t number )
        {
            size_t next_power = number-1;
            next_power |= next_power >> 1;
            next_power |= next_power >> 2;
            next_power |= next_power >> 4;
            next_power |= next_power >> 8;
            next_power |= next_power >> 16;
            ++next_power;

            return next_power;
        }

        void copyArray( T** dst, T* const * src, size_t n )
        {
            for( size_t i = 0; i < n; ++i )
                dst[i] = src[i];
        }

    public:
        vector() : array(nullptr), m_size(0), m_capacity(0) {}
        vector( const vector<T>& vec )
        {
            array = nullptr;
            *this = vec;
        }
        vector( size_t n, const T& val = T() )
        {
            m_capacity = nextGreatestPower( n+1 );
            m_size = n;
            array = new T*[m_capacity];
            for( size_t i = 0; i < n; ++i )
                array[i] = new T(val);
        }
        ~vector()
        {
            clear();
            delete []array;
        }

        typedef vector_iterator<T, vector> iterator;
        typedef vector_const_iterator<T, vector> const_iterator;

        void push_back( const T& value )
        {
            if( m_capacity == 0 )
            {
                array = new T*[2];
                m_capacity = 2;
            }
            else if( m_size >= m_capacity )
                reserve( nextGreatestPower( m_capacity + 1 ) );
            array[m_size] = new T(value);
            ++m_size;
        }

        void pop_back()
        {
            --m_size;
            delete array[m_size];
        }

        void insert( size_t position, const T& value )
        {
            if( m_size == 0 && position == 0 )
            {
                push_back( value );
                return;
            }
            else if( position == m_size && m_size == m_capacity )
            {
                reserve( nextGreatestPower( m_capacity + 1 ) );
            }
            else if( position > m_size )
                throw std::out_of_range( "Vector Subscript Out of Range" );

            for( size_t i = m_size; ; --i )
            {
                if( i == position )
                {
                    array[i] = new T(value);
                    break;
                }
                else
                    array[i] = array[i-1];
            }
            ++m_size;
        }

        void erase( size_t position )
        {
            if( position >= m_size )
                throw std::out_of_range( "Vector Subscript Out of Range" );

            delete array[position];
            for( size_t i = position; i < m_size - 1; ++i )
                array[i] = array[i+1];

            --m_size;
        }

        void clear()
        {
            for( size_t i = 0; i < m_size; ++i )
                delete array[i];
            m_size = 0;
        }

        void reserve( size_t n )
        {
            if( n <= m_capacity )
                return;
            T** tmp = array;
            m_capacity = nextGreatestPower( n );
            array = new T*[ m_capacity ];
            copyArray( array, tmp, m_size );
            delete []tmp;
        }

        size_t size() const
        {
            return m_size;
        }

        size_t capacity() const
        {
            return m_capacity;
        }

        T& front()
        {
            return *array[0];
        }

        const T& front() const
        {
            return *array[0];
        }

        T& back()
        {
            return *array[m_size-1];
        }

        const T& back() const
        {
            return *array[m_size-1];
        }

        iterator begin()
        {
            return iterator( &array[0] );
        }

        const_iterator begin() const
        {
            return const_iterator( &array[0] );
        }

        iterator end()
        {
            return iterator( &array[m_size] );
        }

        const_iterator end() const
        {
            return const_iterator( &array[m_size] );
        }

        T& operator[]( size_t index )
        {
            if( index >= m_size )
                throw std::out_of_range( "Vector Subscript Out of Range" );
            return *array[index];
        }
        const T& operator[]( size_t index ) const
        {
            if( index >= m_size )
                throw std::out_of_range( "Vector Subscript Out of Range" );
            return *array[index];
        }

        void swap( vector<T>& vec )
        {
            std::swap( array, vec.array );
            std::swap( m_size, vec.m_size );
            std::swap( m_capacity, vec.m_capacity );
        }

        vector<T>& operator=( const vector<T> &vec )
        {
            if( this == &vec )
                return *this;
            m_size = vec.size();
            m_capacity = vec.capacity();
            clear();
            T* tmp = array;
            if( vec.capacity() != 0 )
            {
                array = new T[ vec.capacity() ];
                copyArray( array, vec.array, m_size );
            }
            else
                array = nullptr;
            delete []tmp;
            return *this; // umożliwia łańcuchowe przypisywanie np: vec1 = vec2 = vec3 = vec4;
        }
    };
}

#endif