little formating improvement

headers/ftvector.hpp

@@ -15,6 +15,8 @@ public:
 	typedef std::allocator<int>	allocator_type;
 	typedef std::size_t			size_type;
 
+	typedef int *				iterator;
+
 	ftvector();
 	ftvector( ftvector const & src );
 	~ftvector();
@@ -24,74 +26,74 @@ public:
 	/*************
 	 * iterators :
 	 *************/
-	// begin
+// begin -------------------------------------
-//	iterator				begin();
+	iterator				begin();
-//	const_iterator			begin() const;
+	//const_iterator			begin() const;
-	// end
+// end ---------------------------------------
-//	iterator				end();
+	iterator				end();
-//	const_iterator			end() const;
+	//const_iterator			end() const;
-	// rbegin
+// rbegin ------------------------------------
-//	reverse_iterator		rbegin();
+	//reverse_iterator		rbegin();
-//	const_reverse_iterator	rbegin() const;
+	//const_reverse_iterator	rbegin() const;
-	// rend
+// rend --------------------------------------
-//	reverse_iterator		rend();
+	//reverse_iterator		rend();
-//	const_reverse_iterator	rend() const;
+	//const_reverse_iterator	rend() const;
 
 	/************
 	 * capacity :
 	 ************/
-	// size
+// size --------------------------------------
 	size_type	size() const;
-	// max_size
+// max_size ----------------------------------
-//	size_type	max_size() const;
+	//size_type	max_size() const;
-	// resize
+// resize ------------------------------------
-//	void		resize(size_type n, value_type val = value_type());
+	//void		resize(size_type n, value_type val = value_type());
-	// capacity
+// capacity ----------------------------------
-//	size_type	capacity() const;
+	//size_type	capacity() const;
-	// empty
+// empty -------------------------------------
-//	bool		empty() const;
+	//bool		empty() const;
-	//reserve
+// reserve -----------------------------------
 	void		reserve(size_type n);
 
 	/******************
 	 * element access :
 	 ******************/
-	// operator[]
+// operator[] --------------------------------
-//	reference		operator[](size_type n);
+	//reference		operator[](size_type n);
-//	const_reference	operator[](size_type n) const;
+	//const_reference	operator[](size_type n) const;
-	// at
+// at ----------------------------------------
-//	reference		at(size_type n);
+	//reference		at(size_type n);
-//	const_reference	at(size_type n) const;
+	//const_reference	at(size_type n) const;
-	// front
+// front -------------------------------------
-//	reference		front();
+	//reference		front();
-//	const_reference	front() const;
+	//const_reference	front() const;
-	// back
+// back --------------------------------------
-//	reference		back();
+	//reference		back();
-//	const_reference	back() const;
+	//const_reference	back() const;
 
 	/*************
 	 * modifiers :
 	 *************/
-	// assign
+// 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);
+	//void		assign(size_type n, const value_type& val);
-	// push_back
+// push_back ---------------------------------
 	void		push_back(const value_type & val);
-	// pop_back
+// pop_back ----------------------------------
-//	void		pop_back();
+	//void		pop_back();
-	// insert
+// 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
+// erase -------------------------------------
-//	iterator	erase(iterator position);
+	//iterator	erase(iterator position);
-//	iterator	erase(iterator first, iterator last);
+	//iterator	erase(iterator first, iterator last);
-	// swap
+// swap --------------------------------------
-//	void		swap(vector& x);
+	//void		swap(vector& x);
-	// clear
+// clear -------------------------------------
-//	void		clear();
+	//void		clear();
 
 
 private:
@@ -101,6 +103,8 @@ private:
 	value_type *	_mem_ptr;
 	allocator_type	_allocator;
 
+	void			_destroy(iterator first, iterator last);
+
 };
 
 //std::ostream &	operator<<(std::ostream & o, ftvector const & rhs);

srcs/ftvector.cpp

@@ -51,31 +51,35 @@ ftvector &	ftvector::operator=( ftvector const & rhs ) {
 //	return (o);
 //}
 
-/*********************************************
- * ACCESSORS
- *********************************************/
-
-ftvector::size_type	ftvector::size() const {return _size;}
 
 /*********************************************
  * PUBLIC MEMBER FUNCTIONS
  *********************************************/
 
-void	ftvector::push_back(const value_type & element) {
+	/*************
-	if (_size >= _capacity)
+	 * iterators :
-	{
+	 *************/
-		reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
+// begin -------------------------------------
-	}
+ftvector::iterator	ftvector::begin() {return _mem_ptr;}
-	_allocator.construct(&_mem_ptr[_size], element);
+// end ---------------------------------------
-	_size++;
+ftvector::iterator	ftvector::end() {return &_mem_ptr[_size];}
-
+// rbegin ------------------------------------
-	for (size_type i = 0; i < _size; i++)
+// rend --------------------------------------
-		std::cout << _mem_ptr[i] << "\n";
-	std::cout << "\n";
-}
 
+	/************
+	 * capacity :
+	 ************/
+// size --------------------------------------
+ftvector::size_type	ftvector::size() const {return _size;}
+// max_size ----------------------------------
+// resize ------------------------------------
+// capacity ----------------------------------
+// empty -------------------------------------
+// reserve -----------------------------------
 void	ftvector::reserve(size_type new_cap) {
 	value_type *	tmp_ptr;
+	iterator		first = begin();
+	iterator		last = end();
 
 	if (new_cap > _allocator.max_size())
 		throw std::length_error("new_cap > max_size");
@@ -89,19 +93,62 @@ void	ftvector::reserve(size_type new_cap) {
 
 	if (_mem_ptr)
 	{
-		// TMP
+		// TMP replacing assign()
 		for (size_type i = 0; i < _size; i++)
 			tmp_ptr[i] = _mem_ptr[i];
 		// TMP END
+		_destroy(first, last);
 		_allocator.deallocate(_mem_ptr, _capacity);
 	}
 	_mem_ptr = tmp_ptr;
 }
 
+	/******************
+	 * element access :
+	 ******************/
+// operator[] --------------------------------
+// at ----------------------------------------
+// front -------------------------------------
+// back --------------------------------------
+
+	/*************
+	 * modifiers :
+	 *************/
+// assign ------------------------------------
+// push_back ---------------------------------
+void	ftvector::push_back(const value_type & element) {
+	if (_size >= _capacity)
+		reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
+	_allocator.construct(&_mem_ptr[_size], element);
+	_size++;
+
+	// TMP
+	for (size_type i = 0; i < _size; i++)
+		std::cout << _mem_ptr[i] << "\n";
+	std::cout << "\n";
+	// TMP END
+}
+// pop_back ----------------------------------
+// insert ------------------------------------
+// erase -------------------------------------
+// swap --------------------------------------
+// clear -------------------------------------
+
+
+
+
 /*********************************************
  * PRIVATE MEMBER FUNCTIONS
  *********************************************/
 
+void	ftvector::_destroy(iterator first, iterator last) {
+	while (first != last)
+	{
+		_allocator.destroy(first);
+		first++;
+	}
+}
+
 /*********************************************
  * NESTED CLASS
  *********************************************/