Return to Question

• An alternative vector
• An Alternative Vector (Copy Assignment Operator)

• An alternative vector
• An Alternative Vector (Copy Assignment Operator)

 private:
 void validateIndex(size_type index)
 {
 if (index >= length)
 {
 throw std::out_of_range("Out of Range");
 }
 }
 void resizeIfRequire()
 {
 if (length == capacity)
 {
 size_type newCapacity = std::ceil(capacity * 1.62);
 reserveCapacity(newCapacity);
 }
 }
 void reserveCapacity(size_type newCapacity)
 {
 Vector<T> tmpBuffer(newCapacity);
 simpleCopy<T>(tmpBuffer);
 tmpBuffer.swap(*this);
 }
 void pushBackInternal(T const& value)
 {
 new (buffer + length) T(value);
 ++length;
 }
 void moveBackInternal(T&& value)
 {
 new (buffer + length) T(std::forward<T>(value));
 ++length;
 }
 template<typename... Args>
 void constructBackInternal(Args&&... args)
 {
 new (buffer + length) T(std::forward<Args>(args)...);
 ++length;
 }
 template<typename X>
 typename std::enable_if<std::is_nothrow_move_constructible<X>::value == false>::type
 simpleCopy(Vector<T>& dst)
 {
 std::for_each(buffer, buffer + length,
 [&dst](T const& v){dst.pushBackInternal(v);}
 );
 }
 template<typename X>
 typename std::enable_if<std::is_nothrow_move_constructible<X>::value == true>::type
 simpleCopy(Vector<T>& dst)
 {
 std::for_each(buffer, buffer + length,
 [&dst](T& v){dst.moveBackInternal(std::move(v));}
 );
 }
 template<typename X>
 typename std::enable_if<std::is_trivially_destructible<X>::value == false>::type
 clearElements()
 {
 // Call the destructor on all the members in reverse order
 for(int loop = 0; loop < length; ++loop)
 {
 // Note we destroy the elements in reverse order.
 buffer[length - 1 - loop].~T();
 }
 }
 template<typename X>
 typename std::enable_if<std::is_trivially_destructible<X>::value == true>::type
 clearElements()
 {
 // Trivially destructible objects can be re-used without using the destructor.
 }
 template<typename X>
 typename std::enable_if<(std::is_nothrow_copy_constructible<X>::value
 && std::is_nothrow_destructible<X>::value) == true>::type
 copyAssign(Vector<X>& copy)
 {
 if (this == &copy)
 {
 return;
 }
 if (capacity <= copy.length)
 {
 clearElements<T>();
 length = 0;
 for(int loop = 0; loop < copy.length; ++loop)
 {
 pushBackInternal(copy[loop]);
 }
 }
 else
 {
 // Copy and Swap idiom
 Vector<T> tmp(copy);
 tmp.swap(*this);
 }
 }
 template<typename X>
 typename std::enable_if<(std::is_nothrow_copy_constructible<X>::value
 && std::is_nothrow_destructible<X>::value) == false>::type
 copyAssign(Vector<X>& copy)
 {
 // Copy and Swap idiom
 Vector<T> tmp(copy);
 tmp.swap(*this);
 }
};

 private:
 void validateIndex(size_type index)
 {
 if (index >= length)
 {
 throw std::out_of_range("Out of Range");
 }
 }
 void resizeIfRequire()
 {
 if (length == capacity)
 {
 size_type newCapacity = std::max(2.0, capacity * 1.62);
 reserveCapacity(newCapacity);
 }
 }
 void reserveCapacity(size_type newCapacity)
 {
 Vector<T> tmpBuffer(newCapacity);
 simpleCopy<T>(tmpBuffer);
 tmpBuffer.swap(*this);
 }
 void pushBackInternal(T const& value)
 {
 new (buffer + length) T(value);
 ++length;
 }
 void moveBackInternal(T&& value)
 {
 new (buffer + length) T(std::forward<T>(value));
 ++length;
 }
 template<typename... Args>
 void constructBackInternal(Args&&... args)
 {
 new (buffer + length) T(std::forward<Args>(args)...);
 ++length;
 }
 template<typename X>
 typename std::enable_if<std::is_nothrow_move_constructible<X>::value == false>::type
 simpleCopy(Vector<T>& dst)
 {
 std::for_each(buffer, buffer + length,
 [&dst](T const& v){dst.pushBackInternal(v);}
 );
 }
 template<typename X>
 typename std::enable_if<std::is_nothrow_move_constructible<X>::value == true>::type
 simpleCopy(Vector<T>& dst)
 {
 std::for_each(buffer, buffer + length,
 [&dst](T& v){dst.moveBackInternal(std::move(v));}
 );
 }
 template<typename X>
 typename std::enable_if<std::is_trivially_destructible<X>::value == false>::type
 clearElements()
 {
 // Call the destructor on all the members in reverse order
 for(int loop = 0; loop < length; ++loop)
 {
 // Note we destroy the elements in reverse order.
 buffer[length - 1 - loop].~T();
 }
 }
 template<typename X>
 typename std::enable_if<std::is_trivially_destructible<X>::value == true>::type
 clearElements()
 {
 // Trivially destructible objects can be re-used without using the destructor.
 }
 template<typename X>
 typename std::enable_if<(std::is_nothrow_copy_constructible<X>::value
 && std::is_nothrow_destructible<X>::value) == true>::type
 copyAssign(Vector<X>& copy)
 {
 if (this == &copy)
 {
 return;
 }
 if (capacity <= copy.length)
 {
 clearElements<T>();
 length = 0;
 for(int loop = 0; loop < copy.length; ++loop)
 {
 pushBackInternal(copy[loop]);
 }
 }
 else
 {
 // Copy and Swap idiom
 Vector<T> tmp(copy);
 tmp.swap(*this);
 }
 }
 template<typename X>
 typename std::enable_if<(std::is_nothrow_copy_constructible<X>::value
 && std::is_nothrow_destructible<X>::value) == false>::type
 copyAssign(Vector<X>& copy)
 {
 // Copy and Swap idiom
 Vector<T> tmp(copy);
 tmp.swap(*this);
 }
};