vector finish

headers/equal.hpp

@@ -0,0 +1,36 @@
+
+#ifndef EQUAL_HPP
+# define EQUAL_HPP
+
+namespace ft {
+
+template < typename InputIt1, typename InputIt2 >
+	bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2) {
+
+	while (first1 != last1)
+	{
+		if (!(*first1 == *first2))
+			return false;
+		++first1;
+		++first2;
+	}
+	return true;
+}
+
+template < class InputIt1, class InputIt2, class BinaryPred >
+	bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred pred) {
+
+	while (first1 != last1)
+	{
+		if (!pred(*first1, *first2))
+			return false;
+		++first1;
+		++first2;
+	}
+	return true;
+}
+
+} // namespace ft
+
+#endif
+

headers/iterator_traits.hpp

@@ -0,0 +1,44 @@
+
+#ifndef ITERATOR_TRAITS_HPP
+# define ITERATOR_TRAITS_HPP
+
+# include <iterator>	// iterator_tag
+# include <cstddef>		// ptrdiff_t
+
+namespace ft {
+
+template < typename Iterator >
+	struct iterator_traits
+{
+	typedef typename Iterator::iterator_category	iterator_category;
+	typedef typename Iterator::value_type			value_type;
+	typedef typename Iterator::difference_type		difference_type;
+	typedef typename Iterator::pointer				pointer;
+	typedef typename Iterator::reference			reference;
+};
+
+template < typename T >
+	struct iterator_traits<T*>
+{
+	typedef std::random_access_iterator_tag			iterator_category;
+	typedef T										value_type;
+	typedef std::ptrdiff_t							difference_type;
+	typedef T*										pointer;
+	typedef T&										reference;
+};
+
+template < typename T >
+	struct iterator_traits<const T*>
+{
+	typedef std::random_access_iterator_tag			iterator_category;
+	typedef T										value_type;
+	typedef std::ptrdiff_t							difference_type;
+	typedef const T*								pointer;
+	typedef const T&								reference;
+};
+
+} // namespace ft
+
+#endif
+
+// https://www.fluentcpp.com/2018/05/08/std-iterator-deprecated/

headers/lexicographical_compare.hpp

@@ -0,0 +1,42 @@
+
+#ifndef LEXICOGRAPHICAL_COMPARE_HPP
+# define LEXICOGRAPHICAL_COMPARE_HPP
+
+namespace ft {
+
+template <class InputIt1, class InputIt2>
+	bool lexicographical_compare
+	( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) {
+
+	while (first1 != last1)
+	{
+		if (first2 == last2 || *first2 < *first1)
+			return false;
+		else if (*first1 < *first2)
+			return true;
+		++first1;
+		++first2;
+	}
+	return (first2 != last2);
+}
+
+template <class InputIt1, class InputIt2, class Compare>
+	bool lexicographical_compare
+	( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp) {
+
+	while (first1 != last1)
+	{
+		if (first2 == last2 || comp(*first2, *first1))
+			return false;
+		else if (comp(*first1, *first2))
+			return true;
+		++first1;
+		++first2;
+	}
+	return (first2 != last2);
+}
+
+} // namespace ft
+
+#endif
+

headers/reverse_iterator.hpp

@@ -0,0 +1,140 @@
+#ifndef REVERSE_ITERATOR_HPP
+# define REVERSE_ITERATOR_HPP
+
+# include <iterator> // iterator_tag
+# include "iterator_traits.hpp"
+
+namespace ft {
+
+template < class Iter >
+class reverse_iterator {
+
+private:
+
+	Iter								_it;
+	typedef ft::iterator_traits<Iter>	_traits;
+
+public:
+	typedef Iter								iterator_type;
+	typedef typename _traits::iterator_category	iterator_category;
+	typedef typename _traits::value_type		value_type;
+	typedef typename _traits::difference_type	difference_type;
+	typedef typename _traits::pointer			pointer;
+	typedef typename _traits::reference			reference;
+
+
+	/****************
+	 * constructors :
+	 ****************/
+	reverse_iterator()
+		: _it()
+		{}
+	explicit reverse_iterator(iterator_type it)
+		: _it(it)
+		{}	
+//	reverse_iterator(const reverse_iterator& src)
+//		: _it(src._it)
+//		{}
+	template < class Iterator >
+		reverse_iterator(const reverse_iterator<Iterator>& rev_it)
+		: _it(rev_it.base())
+		{}
+
+	/*********************
+	 * members functions :
+	 *********************/
+// base -------------------------------------- 
+	iterator_type base() const
+		{ return _it; }
+// operator * -------------------------------- 
+	reference operator*() const
+		{ Iter tmp = _it; return *--tmp; }
+// operator + -------------------------------- 
+	reverse_iterator operator+(difference_type n) const
+		{ return reverse_iterator(_it - n); }
+// operator ++ ------------------------------- 
+	reverse_iterator operator++(int)
+		{ reverse_iterator old(*this); ++(*this); return old; }
+	reverse_iterator & operator++()
+		{ --_it; return *this; }
+// operator += ------------------------------- 
+	reverse_iterator & operator+=(difference_type n)
+		{ _it -= n; return *this; }
+// operator - -------------------------------- 
+	reverse_iterator operator-(difference_type n) const 
+		{ return reverse_iterator(_it + n); }
+// operator -- ------------------------------- 
+	reverse_iterator operator--(int)
+		{ reverse_iterator old(*this); --(*this); return old; }
+	reverse_iterator & operator--()
+		{ ++_it; return *this; }
+// operator -= ------------------------------- 
+	reverse_iterator & operator-=(difference_type n)
+		{ _it += n; return *this; }
+// operator -> ------------------------------- 
+	pointer operator->() const
+		{ return &(operator*()); }
+// operator [] ------------------------------- 
+	reference operator[] (difference_type n) const
+		{ return _it[-n-1]; }
+};
+
+	/*************************
+	 * non-members functions :
+	 *************************/
+// operator == ------------------------------- 
+template <class Iterator>
+	bool operator== (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() == rhs.base(); }
+// operator != ------------------------------- 
+template <class Iterator>
+	bool operator!= (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() != rhs.base(); }
+// operator < -------------------------------- 
+template <class Iterator>
+	bool operator<  (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() > rhs.base(); }
+// operator <= ------------------------------- 
+template <class Iterator>
+	bool operator<= (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() >= rhs.base(); }
+// operator > -------------------------------- 
+template <class Iterator>
+	bool operator>  (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() < rhs.base(); }
+// operator >= ------------------------------- 
+template <class Iterator>
+	bool operator>= (const reverse_iterator<Iterator>& lhs,
+					 const reverse_iterator<Iterator>& rhs)
+	{ return lhs.base() <= rhs.base(); }
+
+
+	/*******************
+	 * other operators :
+	 *******************/
+// operator + non-member overload ------------ 
+template <class Iterator>
+	reverse_iterator<Iterator> operator+
+		(typename reverse_iterator<Iterator>::difference_type n
+		,const reverse_iterator<Iterator>& rhs)
+	{ return reverse_iterator<Iterator>(rhs.base() - n); }
+
+// operator - non-member overload ------------ 
+template <class Iterator>
+	typename reverse_iterator<Iterator>::difference_type operator-
+		(const reverse_iterator<Iterator>& lhs
+		,const reverse_iterator<Iterator>& rhs)
+	{ return rhs.base() - lhs.base(); }
+
+
+
+
+} // namespace ft
+
+#endif
+

headers/tests.hpp

@@ -2,18 +2,22 @@
 # define TESTS_HPP
 
 #include <iostream>
+#include <string>
 #include "colors.h"
 #include <vector>
-#include <string>
+#include <iomanip>		// std::setw()
+#include <iterator>		// std::reverse_iterator
+#include <utility>		// std::make_pair
+#include <map>			// std::map
 
 
 //                                *************************
 // toogle between test ft and stl
-#include <vector>
 #ifdef STL
 	namespace ft = std;
 #else
 	#include "vector.hpp"
+	#include "reverse_iterator.hpp"
 #endif
 
 
@@ -64,8 +68,8 @@ void	tests_vector_constructor();
 void	tests_vector_operator_assignation();
 void	tests_vector_begin();
 void	tests_vector_end();
-//void	tests_vector_rbegin();
-//void	tests_vector_rend();
+void	tests_vector_rbegin();
+void	tests_vector_rend();
 void	tests_vector_size();
 void	tests_vector_max_size();
 void	tests_vector_resize();
@@ -84,5 +88,8 @@ void	tests_vector_erase();
 void	tests_vector_swap();
 void	tests_vector_clear();
 void	tests_vector_get_allocator();
+void	tests_vector_relational_operators();
+void	tests_vector_swap_non_member();
+void	tests_vector_reverse_iterators();
 
 #endif

headers/vector.hpp

@@ -1,16 +1,19 @@
 #ifndef VECTOR_HPP
 # define VECTOR_HPP
 
+# include "colors.h"
 # include <iostream>
 # include <string>
 # include <memory>		// std::allocator
-# include <algorithm>	// std::min
+# include <algorithm>	// std::min, std::max
 # include <stdexcept>	// out_of_range, length_error, logic_error
-# include <cstddef>		// NULL, size_t, ptrdiff_t
+# include <cstddef>		// NULL, std::size_t, std::ptrdiff_t
 
-# include "colors.h"
 # include "enable_if.hpp"
 # include "is_integral.hpp"
+# include "reverse_iterator.hpp"
+# include "equal.hpp"
+# include "lexicographical_compare.hpp"
 
 namespace ft {
 
@@ -28,15 +31,13 @@ public:
 
 	typedef T *										iterator;
 	typedef T const *								const_iterator;
-//	typedef ft::reverse_iterator<iterator>			reverse_iterator;
-//	typedef ft::reverse_iterator<const_iterator>	const_reverse_iterator;
+	typedef ft::reverse_iterator<iterator>			reverse_iterator;
+	typedef ft::reverse_iterator<const_iterator>	const_reverse_iterator;
 
 	//	dependent qualified name :
 	//	https://en.cppreference.com/w/cpp/keyword/typename
 	typedef typename Allocator::reference			reference;
 	typedef typename Allocator::const_reference		const_reference;
-//	typedef typename Allocator::pointer				pointer;
-//	typedef typename Allocator::const_pointer		const_pointer;
 
 
 
@@ -67,11 +68,12 @@ public:
 	iterator				end();
 	const_iterator			end() const;
 // rbegin ------------------------------------
-//	reverse_iterator		rbegin();
-//	const_reverse_iterator	rbegin() const;
+	reverse_iterator		rbegin();
+	const_reverse_iterator	rbegin() const;
 // rend --------------------------------------
-//	reverse_iterator		rend();
-//	const_reverse_iterator	rend() const;
+	reverse_iterator		rend();
+	const_reverse_iterator	rend() const;
+
 
 	/************
 	 * capacity :
@@ -89,6 +91,7 @@ public:
 // reserve -----------------------------------
 	void		reserve(size_type n);
 
+
 	/******************
 	 * element access :
 	 ******************/
@@ -105,6 +108,7 @@ public:
 	reference		back();
 	const_reference	back() const;
 
+
 	/*************
 	 * modifiers :
 	 *************/
@@ -131,13 +135,13 @@ public:
 // clear -------------------------------------
 	void		clear();
 
+
 	/*************
 	 * allocator :
 	 *************/
 // get_allocator -----------------------------
 	allocator_type	get_allocator() const;
 
-
 private:
 
 	size_type		_size;
@@ -150,7 +154,32 @@ private:
 
 };
 
-//std::ostream &	operator<<(std::ostream & o, vector const & rhs);
+
+	/************************
+	 * non-member functions :
+	 ************************/
+// operator == -------------------------------
+template <class T, class Alloc>
+  bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// operator != -------------------------------
+template <class T, class Alloc>
+  bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// operator < --------------------------------
+template <class T, class Alloc>
+  bool operator<  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// operator <= -------------------------------
+template <class T, class Alloc>
+  bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// operator > --------------------------------
+template <class T, class Alloc>
+  bool operator>  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// operator >= -------------------------------
+template <class T, class Alloc>
+  bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
+// swap (vector) -----------------------------
+template <class T, class Alloc>
+	void swap (vector<T,Alloc>& x, vector<T,Alloc>& y);
+
 
 } // namespace ft