View difference between Paste ID: tFMmLKjP and 5JnCmqM7

 #ifndef MYTEMPLATE_VECTOR
 #define MYTEMPLATE_VECTOR
 
 #include <stdexcept>
 #include <cstdlib>
 
 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 )
 		{
 			array = nullptr;
 			*this = vec;
 		}
 
 		vector( size_t n, const T& val = T() )
 		{
-			array = new T[m_capacity];
+
 			m_size = n;
-				array[i] = val;
+			array = static_cast<T*>( malloc( m_capacity * sizeof( T ) ) );
 			for( size_t i = 0; i < n; ++i )
 				new (&array[i]) T(val);
 		}
-			if( array != nullptr )
+
-				delete []array;
+
 			clear();
 			free(array);
 		}
-			if( m_capacity == 0 )
+
 		{
-				array = new T[2];
+			if( m_capacity == 0 || m_size >= m_capacity )
-				m_capacity = 2;
+				reserve( m_capacity + 2 );
 			array[m_size] = value;
-			else if( m_size >= m_capacity )
+
-				reserve( nextGreatestPower( m_capacity + 1 ) );
+
 
 		void pop_back()
 		{
 			--m_size;
 			array[m_size].~T();
 			new (&array[m_size]) T();
 		}
 
 		void insert( size_t position, const T& value )
 		{
 			if( (m_size == 0 && position == 0) || position == m_size )
-			if( m_size == 0 && position == 0 )
+
 				push_back( value );
 				return;
 			}
 			else if( position > m_size )
-			else if( position == m_size && m_size == m_capacity )
+
 
-				reserve( nextGreatestPower( m_capacity + 1 ) );
+
 			{
-			else if( position >= m_size )
+
 				{
 					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" );
 
 			array[position].~T();
 			new (&array[position]) T();
 			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 clear()
 		{
 			for( size_t i = 0; i < m_size; ++i )
 			{
 				array[i].~T();
 				new (&array[i]) T();
 			}
 
-			array = new T[ m_capacity ];
+			m_size = 0;
 		}
-			if( tmp != nullptr )
+
-				delete tmp;
+
 		{
 			if( n <= m_capacity )
 				return;
 			m_capacity = nextGreatestPower( n );
 			T* tmp = array;
 			array = static_cast<T*>( malloc( m_capacity * sizeof(T) ) );
 			if( array == nullptr )
 				throw std::bad_alloc();
 			for( size_t i = 0; i < m_capacity; ++i )
 				new (&array[i]) T();
 			copyArray( array, tmp, m_size );
 			free(tmp);
 		}
 
 		T& operator[]( size_t index )
-				array = new T[ vec.capacity() ];
+
 			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];
 		}
 
 		vector<T>& operator=( const vector<T> &vec )
 		{
 			if( this == &vec )
 				return *this;
 			m_size = vec.size();
 			m_capacity = vec.capacity();
 			T* tmp = array;
 			if( vec.capacity() != 0 )
 			{
 				array = static_cast<T*>( mallock( m_capacity * sizeof(T) ) );
 				for( size_t i = 0; i < m_capacity; ++i )
 					new (&array[i]) T();
 				copyArray( array, vec.array, m_size );
 			}
 			else
 				array = nullptr;
 			free(tmp);
 			return *this; // umożliwia łańcuchowe przypisywanie np: vec1 = vec2 = vec3 = vec4;
 		}
 	};
 }
 
 #endif