fix push_back reserve growth

headers/vector.hpp

@@ -33,9 +33,9 @@ public:
 	explicit vector (const allocator_type & alloc = allocator_type());
 	explicit vector (size_type n, const value_type& val = value_type(),
 			const allocator_type& alloc = allocator_type());
-//	template <class InputIterator>
+	template <class InputIterator>
-//		vector (InputIterator first, InputIterator last,
+		vector (InputIterator first, InputIterator last,
-//			const allocator_type& alloc = allocator_type());
+			const allocator_type& alloc = allocator_type());
 	vector( vector const & src );
 // destructor --------------------------------
 	~vector();
@@ -95,8 +95,8 @@ public:
 	 * modifiers :
 	 *************/
 // assign ------------------------------------
-	//template <class InputIterator>
+	template <class InputIterator>
-	//	void	assign(InputIterator first, InputIterator last);
+		void	assign(InputIterator first, InputIterator last);
 	void		assign(size_type n, const value_type& val);
 // push_back ---------------------------------
 	void		push_back(const value_type & val);
@@ -113,7 +113,7 @@ public:
 // swap --------------------------------------
 	//void		swap(vector& x);
 // clear -------------------------------------
-	//void		clear();
+	void		clear();
 
 
 private:
@@ -129,9 +129,8 @@ private:
 
 //std::ostream &	operator<<(std::ostream & o, vector const & rhs);
 
-}
+} // namespace ft
 
 # include "vector.tpp"
 
 #endif
-

templates/vector.tpp

@@ -1,7 +1,6 @@
 
-//#include "vector.hpp"
+#define VT_TPL	template <class T, class Allocator>
-
+#define VT		vector<T, Allocator>
-#define COPLIEN_COLOR B_CYAN
 
 namespace ft {
 
@@ -9,39 +8,41 @@ namespace ft {
  * CONSTRUCTORS
  *********************************************/
 
-//	template <class InputIterator>
+VT_TPL VT::
-//		vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
-
-template <class T, class Allocator>
-vector<T, Allocator>::
 vector( const Allocator & alloc )
 : _size(0)
 , _capacity(0)
 , _mem_ptr(NULL)
 , _allocator(alloc)
 {
-//	std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
 	return;
 }
 
-template <class T, class Allocator>
+VT_TPL VT::
-vector<T, Allocator>::
 vector( size_type n, const T & val, const Allocator & alloc )
 : _size(0)
 , _capacity(0)
 , _mem_ptr(NULL)
 , _allocator(alloc)
 {
-//	std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
 	assign(n, val);
 	return;
 }
 
-template <class T, class Allocator>
+VT_TPL template <class InputIterator> VT::
-vector<T, Allocator>::
+	vector(InputIterator first, InputIterator last, const Allocator & alloc)
+: _size(0)
+, _capacity(0)
+, _mem_ptr(NULL)
+, _allocator(alloc)
+{
+	assign(first, last);
+	return;
+}
+
+VT_TPL VT::
 vector( vector const & src )
 {
-//	std::cout << COPLIEN_COLOR "vector copy constructor" RESET "\n";
 	*this = src;
 	return;
 }
@@ -50,11 +51,9 @@ vector( vector const & src )
  * DESTRUCTORS
  *********************************************/
 
-template <class T, class Allocator>
+VT_TPL VT::
-vector<T, Allocator>::
 ~vector()
 {
-//	std::cout << COPLIEN_COLOR "vector destructor" RESET "\n";
 	return;
 }
 
@@ -62,8 +61,7 @@ vector<T, Allocator>::
  * OPERATORS
  *********************************************/
 
-template <class T, class Allocator>
+VT_TPL VT & VT::
-vector<T, Allocator> &	vector<T, Allocator>::
 operator=( vector const & rhs )
 {
 //	Base::operator=(rhs);
@@ -89,46 +87,44 @@ operator=( vector const & rhs )
 	 * iterators :
 	 *************/
 // begin -------------------------------------
-template <class T, class Allocator>
+VT_TPL typename VT::iterator VT::
-typename vector<T, Allocator>::iterator	vector<T, Allocator>::
+	begin() { return _mem_ptr; }
-begin()
+//const_iterator			begin() const;
-{
-	return _mem_ptr;
-}
 // end ---------------------------------------
-template <class T, class Allocator>
+VT_TPL typename VT::iterator VT::
-typename vector<T, Allocator>::iterator	vector<T, Allocator>::
+	end() { return &_mem_ptr[_size]; }
-end()
+//const_iterator			end() const;
-{
-	return &_mem_ptr[_size];
-}
 // rbegin ------------------------------------
+//reverse_iterator		rbegin();
+//const_reverse_iterator	rbegin() const;
 // rend --------------------------------------
+//reverse_iterator		rend();
+//const_reverse_iterator	rend() const;
 
 	/************
 	 * capacity :
 	 ************/
 // size --------------------------------------
-template <class T, class Allocator>
+VT_TPL typename VT::size_type VT::
-typename vector<T, Allocator>::size_type vector<T, Allocator>::
+	size( ) const
-size( ) const
 {
 	return _size;
 }
 // max_size ----------------------------------
+//size_type	max_size() const;
 // resize ------------------------------------
+//void		resize(size_type n, value_type val = value_type());
 // capacity ----------------------------------
-template <class T, class Allocator>
+VT_TPL typename VT::size_type VT::
-typename vector<T, Allocator>::size_type	vector<T, Allocator>::
+	capacity() const
-capacity() const
 {
 	return _capacity;
 }
 // empty -------------------------------------
+//bool		empty() const;
 // reserve -----------------------------------
-template <class T, class Allocator>
+VT_TPL void VT::
-void	vector<T, Allocator>::
+	reserve( size_type new_cap )
-reserve( size_type new_cap )
 {
 	value_type *	tmp_ptr;
 
@@ -158,23 +154,44 @@ reserve( size_type new_cap )
 	 * element access :
 	 ******************/
 // operator[] --------------------------------
-template <class T, class Allocator>
+VT_TPL typename VT::reference VT::
-typename vector<T, Allocator>::reference vector<T, Allocator>::
+	operator[](size_type n) { return _mem_ptr[n]; }
-operator[](size_type n)
+//const_reference	operator[](size_type n) const;
-{
-	return _mem_ptr[n];
-}
 // at ----------------------------------------
+//reference		at(size_type n);
+//const_reference	at(size_type n) const;
 // front -------------------------------------
+//reference		front();
+//const_reference	front() const;
 // back --------------------------------------
+//reference		back();
+//const_reference	back() const;
 
 	/*************
 	 * modifiers :
 	 *************/
 // assign ------------------------------------
-template <class T, class Allocator>
+VT_TPL template <class InputIterator> void VT::
-void	vector<T, Allocator>::
+	assign( InputIterator first, InputIterator last)
-assign( size_type n, const T & val )
+{
+	InputIterator	tmp = first;
+	int				range;
+
+	clear();
+
+	for (range = 1; tmp != last; range++)
+		tmp++;
+	_size += range;
+	if (_size >= _capacity)
+		reserve(_size);
+	while (first != last)
+	{
+		_allocator.construct(&_mem_ptr[_size], first);
+		first++;
+	}
+}
+VT_TPL void VT::
+	assign( size_type n, const T & val )
 {
 	if (n > _allocator.max_size())
 		throw std::length_error("assign: n > max_size");
@@ -195,20 +212,38 @@ assign( size_type n, const T & val )
 		_allocator.construct(&_mem_ptr[--n], val);
 }
 // push_back ---------------------------------
-template <class T, class Allocator>
+VT_TPL void VT::
-void	vector<T, Allocator>::
+	push_back( const value_type & element )
-push_back( const value_type & element )
 {
 	if (_size >= _capacity)
-		reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
+	{
+		if (_size == 0)
+			reserve(1);
+		else
+			reserve(std::min(_size * 2, _allocator.max_size()));
+	}
 	_allocator.construct(&_mem_ptr[_size], element);
 	_size++;
 }
 // pop_back ----------------------------------
+//void		pop_back();
 // insert ------------------------------------
+//iterator	insert(iterator position, const value_type& val);
+//void		insert(iterator position, size_type n, const value_type& val);
+//template <class InputIterator>
+//	void	insert(iterator position, InputIterator first, InputIterator last);
 // erase -------------------------------------
+//iterator	erase(iterator position);
+//iterator	erase(iterator first, iterator last);
 // swap --------------------------------------
+//void		swap(vector& x);
 // clear -------------------------------------
+VT_TPL void VT::
+	clear()
+{
+	_destroy(begin(), end());
+	_size = 0;
+}
 
 
 
@@ -217,9 +252,8 @@ push_back( const value_type & element )
  * PRIVATE MEMBER FUNCTIONS
  *********************************************/
 
-template <class T, class Allocator>
+VT_TPL void VT::
-void	vector<T, Allocator>::
+	_destroy(iterator first, iterator last)
-_destroy(iterator first, iterator last)
 {
 	while (first != last)
 	{
@@ -240,4 +274,7 @@ _destroy(iterator first, iterator last)
 
 //std::string const	vector::_bar = "bar";
 
-}
+} // namespace ft
+
+#undef VT
+#undef VT_TPL

tests/main.cpp

@@ -25,21 +25,21 @@ int	main() {
 		size = myvector.size();
 		for (int i = 0; i < size; i++)
 			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
-		std::cout << "\nsize :" << size << " , capacity :"  << myvector.capacity() << "\n";
+		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
 
 		std::cout << "\nassign 3\n";
 		myvector.assign(3, 12);
 		size = myvector.size();
 		for (int i = 0; i < size; i++)
 			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
-		std::cout << "\nsize :" << size << " , capacity :"  << myvector.capacity() << "\n";
+		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
 
-		std::cout << "\nassign 7268\n";
+	//	std::cout << "\nassign 7268\n";
-		myvector.assign(7268, 12);
+	//	myvector.assign(7268, 12);
-		size = myvector.size();
+	//	size = myvector.size();
-		for (int i = 0; i < size; i++)
+	//	for (int i = 0; i < size; i++)
-			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
+	//		std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
-		std::cout << "\nsize :" << size << " , capacity :"  << myvector.capacity() << "\n";
+	//	std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
 	}
 	TESTEND
 
@@ -337,17 +337,28 @@ int	main() {
 	{
 		ft::vector<int> myvector;
 
+		// first test
 		int	myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
 		int	size = sizeof(myint) / sizeof(myint[0]);
 		for (int i = 0; i < size; i++)
+		{
 			myvector.push_back(myint[i]);
-
+			std::cout << "[capacity : "
+					  << std::setw(2) << myvector.capacity() << "] "
+					  << myvector[i] << "\n";
+		}
 		for (int i = 0; i < size; i++)
 			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << "\n";
+		std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";
 
-		std::cout << "  -> myvector stores " << int(myvector.size()) << " numbers.\n";
+		// second test
-
+	//	for (int i = 0; i < 72363; i++)
-
+	//	{
+	//		myvector.push_back(9);
+	//		std::cout << "[" << i
+	//				  << ":" << myvector.capacity() << "] ";
+	//	}
+	//	std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";
 	}
 	TESTEND