vector fixed 2

#ifndef MYTEMPLATE_VECTOR
#define MYTEMPLATE_VECTOR

#include <stdexcept>

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, const T* 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 )
        {
            *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] = val;
        }
        ~vector()
        {
            if( array != nullptr )
                delete []array;
        }
        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] = value;
            ++m_size;
        }

        void pop_back()
        {
            --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] = 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" );
            for( size_t i = position; i < m_size - 1; ++i )
                array[i] = array[i+1];

            --m_size;
        }

        size_t size() const
        {
            return m_size;
        }

        size_t capacity() const
        {
            return m_capacity;
        }

        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 );
            if( tmp != nullptr )
                delete tmp;
        }

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

        vector<T>& operator=( const vector<T> &vec )
        {
            m_size = vec.size();
            m_capacity = vec.capacity();
            if( vec.capacity() != 0 )
            {
                array = new T[ vec.capacity() ];
                copyArray( array, vec.array, m_size );
            }
            else
                array = nullptr;

            return *this; // umożliwia łańcuchowe przypisywanie np: vec1 = vec2 = vec3 = vec4;
        }
    };
}

#endif