first insert ok

headers/vector.hpp

@@ -24,7 +24,7 @@ public:
 	typedef T										value_type;
 	typedef Allocator								allocator_type;
 	typedef std::size_t								size_type;
-//	typedef std::ptrdiff_t							difference_type;
+	typedef std::ptrdiff_t							difference_type;
 
 	typedef T *										iterator;
 	typedef T const *								const_iterator;
@@ -62,16 +62,16 @@ public:
 	 *************/
 // begin -------------------------------------
 	iterator				begin();
-	//const_iterator			begin() const;
+	const_iterator			begin() const;
 // end ---------------------------------------
 	iterator				end();
-	//const_iterator			end() const;
+	const_iterator			end() const;
 // rbegin ------------------------------------
-	//reverse_iterator		rbegin();
+//	reverse_iterator		rbegin();
-	//const_reverse_iterator	rbegin() const;
+//	const_reverse_iterator	rbegin() const;
 // rend --------------------------------------
-	//reverse_iterator		rend();
+//	reverse_iterator		rend();
-	//const_reverse_iterator	rend() const;
+//	const_reverse_iterator	rend() const;
 
 	/************
 	 * capacity :
@@ -118,18 +118,24 @@ public:
 // pop_back ----------------------------------
 	void		pop_back();
 // insert ------------------------------------
-	//iterator	insert(iterator position, const value_type& val);
+	iterator	insert(iterator position, const value_type& val);
-	//void		insert(iterator position, size_type n, const value_type& val);
+//	void		insert(iterator position, size_type n, const value_type& val);
-	//template <class InputIterator>
+//	template <class InputIterator>
-	//	void	insert(iterator position, InputIterator first, InputIterator last);
+//		void	insert(iterator position, InputIterator first, InputIterator last);
 // erase -------------------------------------
-	//iterator	erase(iterator position);
+	iterator	erase(iterator position);
-	//iterator	erase(iterator first, iterator last);
+	iterator	erase(iterator first, iterator last);
 // swap --------------------------------------
-	//void		swap(vector& x);
+	void		swap(vector& x);
 // clear -------------------------------------
 	void		clear();
 
+	/*************
+	 * allocator :
+	 *************/
+// get_allocator -----------------------------
+	allocator_type	get_allocator() const;
+
 
 private:
 

templates/vector.tpp

@@ -37,6 +37,7 @@ VT_TPL template <class InputIterator> VT::
 	assign(first, last);
 	return;
 }
+// copy constructor --------------------------
 VT_TPL VT::
 	vector( vector const & src ) {
 
@@ -50,15 +51,19 @@ VT_TPL VT::
 VT_TPL VT & VT::
 	operator=( vector const & rhs ) {
 
+	vector	new_vector;
+
 	//Base::operator=(rhs);
 	if ( this != &rhs )
 	{
-		_size = rhs.size();
+		new_vector.reserve(_capacity);
+		new_vector.assign(rhs.begin(), rhs.end());
+		swap(new_vector);
+		//_size = rhs.size();
 	}
 	return *this;
 }
 
-
 /*********************************************
  * PUBLIC MEMBER FUNCTIONS
  *********************************************/
@@ -69,17 +74,23 @@ VT_TPL VT & VT::
 // begin -------------------------------------
 VT_TPL typename VT::iterator VT::
 	begin() { return _mem_ptr; }
-//const_iterator			begin() const;
+VT_TPL typename VT::const_iterator VT::
+	begin() const { return _mem_ptr; }
 // end ---------------------------------------
 VT_TPL typename VT::iterator VT::
 	end() { return &_mem_ptr[_size]; }
-//const_iterator			end() const;
+VT_TPL typename VT::const_iterator VT::
+	end() const { return &_mem_ptr[_size]; }
 // rbegin ------------------------------------
-//reverse_iterator		rbegin();
+//VT_TPL typename VT::reverse_iterator VT::
-//const_reverse_iterator	rbegin() const;
+//	rbegin() { return reverse_iterator(end()); }
+//VT_TPL typename VT::const_reverse_iterator VT::
+//	rbegin() const { return const_reverse_iterator(end()); }
 // rend --------------------------------------
-//reverse_iterator		rend();
+//VT_TPL typename VT::reverse_iterator VT::
-//const_reverse_iterator	rend() const;
+//	rend() { return reverse_iterator(begin()); }
+//VT_TPL typename VT::const_reverse_iterator VT::
+//	rend() const { return const_reverse_iterator(begin()); }
 
 	/************
 	 * capacity :
@@ -234,21 +245,108 @@ VT_TPL void VT::
 VT_TPL void VT::
 	pop_back() { _allocator.destroy(end() - 1); _size--; }
 // insert ------------------------------------
-//iterator	insert(iterator position, const value_type& val);
+VT_TPL typename VT::iterator VT::
-//void		insert(iterator position, size_type n, const value_type& val);
+	insert(iterator position, const value_type& val) {
-//template <class InputIterator>
+
-//	void	insert(iterator position, InputIterator first, InputIterator last);
+	difference_type	distance;
+	iterator		it;
+
+	if (_size + 1 > _capacity)
+	{
+		distance = position - begin();
+		_increment_capacity(1);
+		position = begin() + distance;
+	}
+	it = end();
+	if (position != it)
+	{
+		_allocator.construct(it, *(it - 1));
+		while (--it != position)
+			*(it + 1) = *it;
+	}
+	_allocator.destroy(position);
+	_allocator.construct(position, val);
+	_size++;
+	return (position);
+}
+//VT_TPL void VT::
+//	insert(iterator position, size_type n, const value_type& val) {
+//
+//}
+//VT_TPL template <class InputIterator> void VT::
+//	insert(iterator position, InputIterator first, InputIterator last) {
+//
+//}
 // erase -------------------------------------
-//iterator	erase(iterator position);
+VT_TPL typename VT::iterator VT::
-//iterator	erase(iterator first, iterator last);
+	erase(iterator position) {
+
+	iterator	i = position;
+	iterator	it_end = end() - 1;
+
+	while (i != it_end)
+	{   
+		*i = *(i + 1);
+		++i;
+	}
+	_allocator.destroy(it_end);
+	_size -= 1;
+	return (position);
+}
+VT_TPL typename VT::iterator VT::
+	erase(iterator first, iterator last) {
+
+	iterator		it_end = end();
+	difference_type	diff = std::distance(first, last);
+
+	if (diff <= 0)
+		return (first);
+
+	it_end = end();
+	while (last != it_end)
+	{
+		*first = *last;
+		first++;
+		last++;
+	}
+	_destroy(it_end - diff, it_end);
+	_size -= diff;
+
+	return (first);
+}
 // swap --------------------------------------
-//void		swap(vector& x);
+VT_TPL void VT::
+	swap(vector& x) {
+
+	T*			tmp_mem_ptr;
+	size_type	tmp_size;
+	size_type	tmp_capacity;
+
+	tmp_mem_ptr = x._mem_ptr;
+	tmp_size = x._size;
+	tmp_capacity = x._capacity;
+
+	x._mem_ptr = _mem_ptr;
+	x._size = _size;
+	x._capacity = _capacity;
+
+	_mem_ptr = tmp_mem_ptr;
+	_size = tmp_size;
+	_capacity = tmp_capacity;
+}
 // clear -------------------------------------
 VT_TPL void VT::
 	clear() { _destroy(begin(), end()); _size = 0; }
 
 
 
+/*************
+ * allocator :
+ *************/
+// get_allocator -----------------------------
+VT_TPL typename VT::allocator_type VT::
+	get_allocator() const { return (_allocator); }
+
 
 /*********************************************
  * PRIVATE MEMBER FUNCTIONS

tests/main.cpp

@@ -11,6 +11,8 @@
 	#include "vector.hpp"
 #endif
 
+struct mystruct { int value; };
+
 int	main() {
 
 /*
@@ -42,14 +44,33 @@ int	main() {
 		// title
 		TITLE(cplusplus.com reference :)
 
-		std::vector<int> foo (3,0);
+		ft::vector<int> foo (3,0);
-		std::vector<int> bar (5,0);
+		ft::vector<int> bar (5,0);
 
 		bar = foo;
-		foo = std::vector<int>();
+		foo = ft::vector<int>();
 
 		std::cout << "Size of foo: " << int(foo.size()) << '\n';
 		std::cout << "Size of bar: " << int(bar.size()) << '\n';
+
+
+		// title
+		TITLE(more informations :)
+
+		int	size;
+
+		size = foo.size();
+		std::cout << "foo:\n";
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i <<"]" << foo[i];
+		std::cout << "\ncapacity: " << foo.capacity() << "\n";
+
+		size = bar.size();
+		std::cout << "bar:\n";
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i <<"]" << bar[i];
+		std::cout << "\ncapacity: " << bar.capacity() << "\n";
+
 	}
 	TESTEND
 
@@ -84,8 +105,10 @@ int	main() {
 		std::cout << '\n';
 	}
 	TESTEND
+*/
 
 
+/*
 	TEST(vector::rbegin)
 	{
 		// title
@@ -126,8 +149,10 @@ int	main() {
 		std::cout << '\n';
 	}
 	TESTEND
+*/
 
 
+/*
 	TEST(vector::size)
 	{
 		// title
@@ -153,7 +178,7 @@ int	main() {
 		// title
 		TITLE(cplusplus.com reference :)
 
-		std::vector<int> myvector;
+		ft::vector<int> myvector;
 
 		// set some content in the vector:
 		for (int i=0; i<100; i++) myvector.push_back(i);
@@ -163,7 +188,6 @@ int	main() {
 		std::cout << "max_size: " << myvector.max_size() << "\n";
 	}
 	TESTEND
-*/
 
 
 	TEST(vector::resize)
@@ -599,44 +623,101 @@ int	main() {
 		std::cout << "capacity : "	<< myvector.capacity() << '\n';
 	}
 	TESTEND
+*/
 
 
-/*
 	TEST(vector::insert)
 	{
+//		// title
+//		TITLE(cplusplus.com reference :)
+//
+//		std::vector<int> myvector (3,100);
+//		std::vector<int>::iterator it;
+//
+//		it = myvector.begin();
+//		it = myvector.insert ( it , 200 );
+//
+//		myvector.insert (it,2,300);
+//
+//		// "it" no longer valid, get a new one:
+//		it = myvector.begin();
+//
+//		std::vector<int> anothervector (2,400);
+//		myvector.insert (it+2,anothervector.begin(),anothervector.end());
+//
+//		int myarray [] = { 501,502,503 };
+//		myvector.insert (myvector.begin(), myarray, myarray+3);
+//
+//		std::cout << "myvector contains:";
+//		for (it=myvector.begin(); it<myvector.end(); it++)
+//			std::cout << ' ' << *it;
+//		std::cout << '\n';
+
+
 		// title
-		TITLE(cplusplus.com reference :)
+		TITLE(tests positions on insert(pos, value) :)
 
-		std::vector<int> myvector (3,100);
+		ft::vector<int>				myvector2 (3,100);
-		std::vector<int>::iterator it;
+		ft::vector<int>::iterator	it2;
-
-		it = myvector.begin();
-		it = myvector.insert ( it , 200 );
-
-		myvector.insert (it,2,300);
-
-		// "it" no longer valid, get a new one:
-		it = myvector.begin();
-
-		std::vector<int> anothervector (2,400);
-		myvector.insert (it+2,anothervector.begin(),anothervector.end());
-
-		int myarray [] = { 501,502,503 };
-		myvector.insert (myvector.begin(), myarray, myarray+3);
 
+		it2 = myvector2.begin();
+		std::cout << "\nsize:" << myvector2.size() << " capacity:" << myvector2.capacity() << "\n";
+		myvector2.insert ( it2 , 200 );
 		std::cout << "myvector contains:";
-		for (it=myvector.begin(); it<myvector.end(); it++)
+		for (it2 = myvector2.begin(); it2 < myvector2.end(); it2++)
-			std::cout << ' ' << *it;
+			std::cout << ' ' << *it2;
-		std::cout << '\n';
+		std::cout << "\nsize:" << myvector2.size() << " capacity:" << myvector2.capacity() << "\n";
+
+		ft::vector<int>				myvector3 (3,100);
+		ft::vector<int>::iterator	it3;
+
+		it3 = myvector3.end();
+		std::cout << "\nsize:" << myvector3.size() << " capacity:" << myvector3.capacity() << "\n";
+		myvector3.insert ( it3 , 200 );
+		std::cout << "myvector contains:";
+		for (it3 = myvector3.begin(); it3 < myvector3.end(); it3++)
+			std::cout << ' ' << *it3;
+		std::cout << "\nsize:" << myvector3.size() << " capacity:" << myvector3.capacity() << "\n";
+
+
+		// title
+		TITLE(tests positions on insert(pos, value) with struct :)
+
+		mystruct	s_1;
+		mystruct	s_2;
+
+		s_1.value = 1;
+		s_2.value = 2;
+
+		ft::vector<mystruct>			myvector4 (3,s_1);
+		ft::vector<mystruct>::iterator	it4;
+
+		it4 = myvector4.begin();
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+		myvector4.insert ( it4 , s_2 );
+		std::cout << "myvector contains:";
+		for (it4 = myvector4.begin(); it4 < myvector4.end(); it4++)
+			std::cout << ' ' << (*it4).value;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+
+		it4 = myvector4.begin() + 2;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+		myvector4.insert ( it4 , s_2 );
+		std::cout << "myvector contains:";
+		for (it4 = myvector4.begin(); it4 < myvector4.end(); it4++)
+			std::cout << ' ' << (*it4).value;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
 	}
 	TESTEND
 
+
+/*
 	TEST(vector::erase)
 	{
 		// title
 		TITLE(cplusplus.com reference :)
 
-		std::vector<int> myvector;
+		ft::vector<int> myvector;
 
 		// set some values (from 1 to 10)
 		for (int i=1; i<=10; i++) myvector.push_back(i);
@@ -651,9 +732,43 @@ int	main() {
 		for (unsigned i=0; i<myvector.size(); ++i)
 			std::cout << ' ' << myvector[i];
 		std::cout << '\n';
+
+
+		// title
+		TITLE(test iterator bigger or equal :)
+		ft::vector<int>	vector2;
+		int				size;
+
+		for (int i=1; i<=100; i++) vector2.push_back(i);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(7,36) :\n";
+		vector2.erase(vector2.begin() + 7, vector2.begin() + 36);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(46,54) :\n";
+		vector2.erase(vector2.begin() + 46, vector2.begin() + 54);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(7,7) :\n";
+		vector2.erase(vector2.begin() + 7, vector2.begin() + 7);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
 	}
 	TESTEND
 
+
 	TEST(vector::swap)
 	{
 		// title
@@ -676,6 +791,7 @@ int	main() {
 	}
 	TESTEND
 
+
 	TEST(vector::clear)
 	{
 		// title
@@ -702,6 +818,7 @@ int	main() {
 	}
 	TESTEND
 
+
 	TEST(vector::get_allocator)
 	{
 		// title