reverse iterator almost done

containers/iterators/random_access_iterator.hpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/30 16:14:35 by apommier          #+#    #+#             */
-/*   Updated: 2022/11/19 12:42:38 by apommier         ###   ########.fr       */
+/*   Updated: 2022/11/21 15:54:44 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,10 +22,11 @@ namespace ft
 	{
 		public:
 
-			typedef T				value_type;
+			typedef T							value_type;
-			typedef	std::ptrdiff_t	difference_type;	
+			typedef	std::ptrdiff_t				difference_type;	
-			typedef	T*				pointer;
+			typedef	T*							pointer;
-			typedef	T&				reference;
+			typedef	T&							reference;
+			typedef random_access_iterator		iterator_category;
 
 		private:	
 			
@@ -59,16 +60,7 @@ namespace ft
 		// 	return (*this);
 		// }
 		
-		//---------------------------------------
-		//-------------COMPARAISON---------------
-		//---------------------------------------
 
-		friend bool operator ==(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr == b._ptr); }
-		friend bool operator !=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr != b._ptr); }
-		friend bool operator <(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr < b._ptr); }
-		friend bool operator >(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr > b._ptr); }
-		friend bool operator <=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr <= b._ptr); }
-		friend bool operator >=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr >= b._ptr); }
 
 		//---------------------------------------
 		//-------------INCREMENTERS--------------
@@ -118,7 +110,7 @@ namespace ft
 		// addition | soustraction
 		random_access_iterator operator +(difference_type const nbr) const { return (random_access_iterator(_ptr + nbr)); } // a + n
 		friend random_access_iterator operator +(int const lhs, random_access_iterator const& rhs) { return (rhs + lhs); } // n + a
-		random_access_iterator operator -(difference_type nbr) { return random_access_iterator(_ptr - nbr); } // a - n
+		random_access_iterator operator -(difference_type nbr) const { return random_access_iterator(_ptr - nbr); } // a - n
 		difference_type operator -(random_access_iterator const &rhs) const { return (_ptr - rhs._ptr) ; } // a - b
 		//friend difference_type &operator -(random_access_iterator const& lhs, random_access_iterator const& rhs) { return ((difference_type)(lhs._ptr - rhs._ptr)); } // a - b
 		//random_access_iterator operator -(const random_access_iterator &b) { return random_access_iterator(_ptr + b); } // a - b 2?
@@ -143,9 +135,52 @@ namespace ft
 		{
 			return (_ptr);
 		}
+
+		//---------------------------------------
+		//-------------COMPARAISON---------------
+		//---------------------------------------
+
+		// bool operator ==(const random_access_iterator &b) { return (this->_ptr == b._ptr); }
+		// bool operator !=(const random_access_iterator &b) { return (this->_ptr != b._ptr); }
+		// bool operator <(const random_access_iterator &b) { return (this->_ptr < b._ptr); }
+		// bool operator >(const random_access_iterator &b) { return (this->_ptr > b._ptr); }
+		// bool operator <=(const random_access_iterator &b) { return (this->_ptr <= b._ptr); }
+		// bool operator >=(const random_access_iterator &b) { return (this->_ptr >= b._ptr); }
+		friend bool operator ==(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr == b._ptr); }
+		friend bool operator !=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr != b._ptr); }
+		friend bool operator <(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr < b._ptr); }
+		friend bool operator >(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr > b._ptr); }
+		friend bool operator <=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr <= b._ptr); }
+		friend bool operator >=(random_access_iterator const& a, random_access_iterator const& b) { return (a._ptr >= b._ptr); }
 	};
 
+	//---------------------------------------
+	//-------------COMPARAISON---------------
+	//---------------------------------------
 	
+	// template<typename _Ite>
+	// bool operator ==(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr == b._ptr); }
+	// template<typename _Ite>
+	// bool operator !=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr != b._ptr); }
+	// template<typename _Ite>
+	// bool operator <(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr < b._ptr); }
+	// template<typename _Ite>
+	// bool operator >(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr > b._ptr); }
+	// template<typename _Ite>
+	// bool operator <=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr <= b._ptr); }
+	// template<typename _Ite>
+	// bool operator >=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr >= b._ptr); }
 }
 
+	// template <typename U>
+	// ft::random_access_iterator<U> operator +(std::ptrdiff_t const nbr, ft::random_access_iterator<U> const& rhs)
+	// {
+	// 	return (rhs + nbr);
+	// } // n + a
+	// template<class _Iterator>
+	// ft::random_access_iterator<_Iterator> operator+(typename ft::random_access_iterator<_Iterator>::difference_type n, ft::random_access_iterator<_Iterator> const &lhs) 
+	// {
+	// 	return (lhs + n);
+	// }
+
 #endif

containers/iterators/reverse_iterator.hpp

@@ -6,14 +6,14 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/11/19 05:14:31 by apommier          #+#    #+#             */
-/*   Updated: 2022/11/19 05:49:52 by apommier         ###   ########.fr       */
+/*   Updated: 2022/11/22 06:15:05 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#ifndef REVERSE_ITERATOR_HPP
+#pragma once
-# define REVERSE_ITERATOR_HPP
 
 # include <cstddef>
+# include "./iterator_traits.hpp"
 
 namespace ft 
 {
@@ -31,7 +31,7 @@ namespace ft
 
 		private:	
 			
-			Iter	_Ite;
+			iterator_type	_Ite;
 
 		public:
 		
@@ -39,45 +39,121 @@ namespace ft
 		//--------CONSTRUCTOR DESTRUCTOR---------
 		//---------------------------------------
 		
-		reverse_iterator(){}
+		reverse_iterator() : _Ite() {}
-		reverse_iterator(pointer Ite){}
+		explicit reverse_iterator (iterator_type it) { _Ite = iterator_type(it); }
-		reverse_iterator(reverse_iterator const &cpy) {}
 		
-		~reverse_iterator(){}
+		template<typename It>
+		reverse_iterator(const reverse_iterator<It> &rev_it)
+		{
+			_Ite = rev_it.base(); 
+		}
 
 		reverse_iterator &operator=(reverse_iterator const &cpy)
 		{
-			_Ite = cpy._Ite;
+			_Ite = iterator_type(cpy._Ite); 
 			return (*this);
 		}
 		
+		virtual ~reverse_iterator(){}
+		
 		//---------------------------------------
 		//-------------COMPARAISON---------------
 		//---------------------------------------
 		
+		bool operator== (reverse_iterator const &rhs) const { return (_Ite == rhs._Ite); }
+		bool operator!= (reverse_iterator const &rhs) const { return (_Ite != rhs._Ite); }
+		bool operator<  (reverse_iterator const &rhs) const { return (_Ite > rhs._Ite); }
+		bool operator<= (reverse_iterator const &rhs) const { return (_Ite >= rhs._Ite); }
+		bool operator>  (reverse_iterator const &rhs) const { return (_Ite < rhs._Ite); }
+		bool operator>= (reverse_iterator const &rhs) const { return (_Ite <= rhs._Ite); }
+
 		//---------------------------------------
 		//-------------INCREMENTERS--------------
 		//---------------------------------------
 
+		reverse_iterator& operator++()
+		{
+			--_Ite;
+			return (*this);
+		}
+		
+		reverse_iterator  operator++(int) 
+		{
+			reverse_iterator tmp = *this;
+			--_Ite;
+			return (tmp);
+		}
+		
+		reverse_iterator& operator--() 
+		{
+			++_Ite;
+			return (*this);
+		}
+		
+		reverse_iterator  operator--(int)
+		{
+			reverse_iterator tmp = *this;
+			++_Ite;
+			return (tmp);
+		}
+
 		//---------------------------------------
 		//----------------ADRESS-----------------
 		//---------------------------------------
 
 		reference operator *() { return (*_Ite); }
 		const reference operator *() const { return (*_Ite); }
-		pointer operator ->() { return (_Ite); }
+		pointer operator ->() { return (_Ite.getPointer()); }
-		const pointer operator ->() const { return (_Ite); }
+		const pointer operator ->() const { return (_Ite.getPointer()); }
 		reference operator [](difference_type nbr) const { return (*(_Ite + nbr)); }
 
 		//---------------------------------------
 		//--------------OPERATION----------------
 		//---------------------------------------
 
+		// reverse_iterator operator+ (difference_type n) const { return reverse_iterator<iterator_type>(_Ite - n); }
+		// reverse_iterator& operator+= (difference_type n) { return reverse_iterator<iterator_type>(_Ite -= n); }
+		// reverse_iterator operator- (difference_type n) const { return reverse_iterator<iterator_type>(_Ite + n); }
+		// reverse_iterator& operator-= (difference_type n) { return reverse_iterator<iterator_type>(_Ite += n); }
+
+		reverse_iterator operator+ (difference_type n) const { return reverse_iterator(_Ite - n); }
+		
+		friend reverse_iterator operator +(difference_type lhs, reverse_iterator const& rhs) { return (rhs + lhs); } // n + a
+
+		reverse_iterator& operator+= (difference_type n)
+		{
+			_Ite -= n;
+			return (*this);
+		}
+		
+		reverse_iterator operator- (difference_type n) const { return reverse_iterator(_Ite + n); }
+		
+		difference_type operator- (reverse_iterator const &lhs) const { return (_Ite - lhs._Ite); }
+
+		reverse_iterator& operator-= (difference_type n)
+		{
+			//std::cout << "its me\n";
+			_Ite += n;
+			return (*this);
+		}
+
+
+		// template <class Iterator>
+		// reverse_iterator<Iterator> operator+ (typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& rev_it)
+		// {
+			
+		// }
+
+		// template <class Iterator>
+		// typename reverse_iterator<Iterator>::difference_type operator- ( const reverse_iterator<Iterator>& lhs, const reverse_iterator<Iterator>& rhs)
+		// {
+			
+		// }
+
 		//---------------------------------
 		//--------------GET----------------
 		//---------------------------------
 
+		iterator_type base() const { return iterator_category(_Ite); }
 	};
-
-	
 }

containers/vector.hpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/10/12 19:46:32 by apommier          #+#    #+#             */
-/*   Updated: 2022/11/20 02:57:45 by apommier         ###   ########.fr       */
+/*   Updated: 2022/11/21 18:48:56 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,6 +16,7 @@
 # include "./iterators/random_access_iterator.hpp"
 # include "./iterators/enable_if.hpp"
 # include "./iterators/is_integral.hpp"
+# include "./iterators/reverse_iterator.hpp"
 
 # include <cstddef>
 # include <memory>
@@ -40,8 +41,8 @@ class vector
 	typedef const T*										const_pointer;
 	typedef ft::random_access_iterator<value_type>			iterator;
 	typedef ft::random_access_iterator<const value_type>	const_iterator;
-	typedef std::reverse_iterator<iterator>					reverse_iterator;
+	typedef ft::reverse_iterator<iterator>					reverse_iterator;
-	typedef std::reverse_iterator<const_iterator>			const_reverse_iterator;
+	typedef ft::reverse_iterator<const_iterator>			const_reverse_iterator;
 	typedef std::ptrdiff_t									difference_type;
 	typedef std::size_t										size_type;
 	 
@@ -90,12 +91,18 @@ class vector
 
 	~vector()
 	{
-		if (_capacity)
+		//std::cout << "destct" << std::endl;
+		if (_capacity == 0)
+		{
 			_alloc.deallocate(_tab, _capacity);
+			_capacity = 0;
+		}
+		//std::cout << "destct end" << std::endl;
 	}
 	
 	vector& operator= (const vector& x)//assignation operator
 	{
+			//this->~vector();
 			_alloc = x._alloc;
 			_size = x._size;
 			_capacity = x._size;
@@ -134,22 +141,22 @@ class vector
 		
 		reverse_iterator rbegin()
 		{
-			return iterator(_tab + _size);
+			return reverse_iterator(_tab);
 		}
 
 		const_reverse_iterator rbegin() const
 		{
-			return iterator(_tab + _size);
+			return const_reverse_iterator(_tab);
 		}
 		
 		reverse_iterator rend()
 		{
-			return (_tab);
+			return reverse_iterator(_tab + _size);
 		}
 
 		const_reverse_iterator rend() const
 		{
-			return (_tab);
+			return const_reverse_iterator(_tab + _size);
 		}
 		
 		//------------------------
@@ -167,7 +174,7 @@ class vector
 		
 		void resize (size_type n, value_type val = value_type()) //Resizes the container so that it contains n elements.
 		{
-			
+			//std::cout << "resize------val = " << val << std::endl;
 			if (n < _size) 
 			{
 				while (n < _size)
@@ -186,8 +193,9 @@ class vector
 					_size++;
 					//_end++;
 				}
-				//_size = n;
+				
 			}
+			//_size = n;
 		}
 		
 		size_type capacity() const
@@ -450,6 +458,30 @@ class vector
 			return (_alloc);
 		}
 	
+		//-------------------------
+		//-------Comparaison-------
+		//-------------------------
+
+		// bool operator ==(const random_access_iterator &b) { return (this->_tab == b); }
+		// bool operator !=(const random_access_iterator &b) { return (this->_tab != b); }
+		// bool operator <(const random_access_iterator &b) { return (this->_tab < b); }
+		// bool operator >(const random_access_iterator &b) { return (this->_tab > b); }
+		// bool operator <=(const random_access_iterator &b) { return (this->_tab <= b); }
+		// bool operator >=(const random_access_iterator &b) { return (this->_tab >= b); }
+		
+		template <class Temp, class Alloc>
+		friend bool operator== (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs);
+		template <class Temp, class Alloc>
+		friend bool operator!= (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs);
+		template <class Temp, class Alloc>
+		friend bool operator<  (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs); 
+		template <class Temp, class Alloc>
+		friend bool operator<= (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs);
+		template <class Temp, class Alloc>
+		friend bool operator>  (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs);
+		template <class Temp, class Alloc>
+		friend bool operator>= (const vector<Temp,Alloc>& lhs, const vector<Temp,Alloc>& rhs);
+
 	//---------------------------------------------
 	//---------OPERATOR OVERLOAD FUNCTION----------
 	//---------------------------------------------
@@ -491,5 +523,57 @@ class vector
 	// }
 };
 	
+	template <class T, class Alloc>  
+	bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		if (lhs._size != rhs._size)
+			return (lhs._size == rhs._size);
+		
+		int i = 0;
+		while (lhs._size - i && lhs._tab[i] == rhs._tab[i])
+			i++;
+		return (lhs._tab[i] == rhs._tab[i]);
+	}
+	
+	template <class T, class Alloc>  
+	bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		return (!(lhs == rhs));
+	}
+	
+	template <class T, class Alloc>  
+	bool operator<  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		int i = 0;
+		while (lhs._size - i && rhs._size - i && lhs._tab[i] == rhs._tab[i])
+			i++;
+		if (!(lhs._size - i) && rhs._size - i)
+			return true;
+		if (!(rhs._size - i) && lhs._size - i)
+			return false;
+		if (!(lhs._size - i) && !(rhs._size - i))
+			return false;
+		return (lhs._tab[i] < rhs._tab[i]);
+	}
+	
+	template <class T, class Alloc>  
+	bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		return (!(rhs < lhs));
+	}
+	
+	template <class T, class Alloc>  
+	bool operator>  (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		return (rhs < lhs);
+	}
+	
+	template <class T, class Alloc>  
+	bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
+	{
+		return (!(lhs < rhs));
+	}
+	
+	
 }
 #endif