diff --git a/containers/iterators/random_access_iterator.hpp b/containers/iterators/random_access_iterator.hpp index c9fbf71..5e224dc 100644 --- a/containers/iterators/random_access_iterator.hpp +++ b/containers/iterators/random_access_iterator.hpp @@ -6,7 +6,7 @@ /* By: apommier +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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 std::ptrdiff_t difference_type; - typedef T* pointer; - typedef T& reference; + typedef T value_type; + typedef std::ptrdiff_t difference_type; + typedef T* pointer; + 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 + // bool operator ==(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr == b._ptr); } + // template + // bool operator !=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr != b._ptr); } + // template + // bool operator <(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr < b._ptr); } + // template + // bool operator >(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr > b._ptr); } + // template + // bool operator <=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr <= b._ptr); } + // template + // bool operator >=(const random_access_iterator<_Ite> &a, const random_access_iterator<_Ite> &b) { return (a._ptr >= b._ptr); } } + // template + // ft::random_access_iterator operator +(std::ptrdiff_t const nbr, ft::random_access_iterator const& rhs) + // { + // return (rhs + nbr); + // } // n + a + // template + // 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 \ No newline at end of file diff --git a/containers/iterators/reverse_iterator.hpp b/containers/iterators/reverse_iterator.hpp index ce8c2e6..e264f10 100644 --- a/containers/iterators/reverse_iterator.hpp +++ b/containers/iterators/reverse_iterator.hpp @@ -6,14 +6,14 @@ /* By: apommier +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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 -# define REVERSE_ITERATOR_HPP +#pragma once # include +# include "./iterator_traits.hpp" namespace ft { @@ -28,10 +28,10 @@ namespace ft typedef typename ft::iterator_traits::difference_type difference_type; typedef typename ft::iterator_traits::pointer pointer; typedef typename ft::iterator_traits::reference reference; - + private: - Iter _Ite; + iterator_type _Ite; public: @@ -39,45 +39,121 @@ namespace ft //--------CONSTRUCTOR DESTRUCTOR--------- //--------------------------------------- - reverse_iterator(){} - reverse_iterator(pointer Ite){} - reverse_iterator(reverse_iterator const &cpy) {} - - ~reverse_iterator(){} + reverse_iterator() : _Ite() {} + explicit reverse_iterator (iterator_type it) { _Ite = iterator_type(it); } + template + reverse_iterator(const reverse_iterator &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); } - const pointer operator ->() const { return (_Ite); } + pointer operator ->() { return (_Ite.getPointer()); } + 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(_Ite - n); } + // reverse_iterator& operator+= (difference_type n) { return reverse_iterator(_Ite -= n); } + // reverse_iterator operator- (difference_type n) const { return reverse_iterator(_Ite + n); } + // reverse_iterator& operator-= (difference_type n) { return reverse_iterator(_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 + // reverse_iterator operator+ (typename reverse_iterator::difference_type n, const reverse_iterator& rev_it) + // { + + // } + + // template + // typename reverse_iterator::difference_type operator- ( const reverse_iterator& lhs, const reverse_iterator& rhs) + // { + + // } + //--------------------------------- //--------------GET---------------- //--------------------------------- + iterator_type base() const { return iterator_category(_Ite); } }; - - } \ No newline at end of file diff --git a/containers/vector.hpp b/containers/vector.hpp index 45da700..e0a6ed7 100644 --- a/containers/vector.hpp +++ b/containers/vector.hpp @@ -6,7 +6,7 @@ /* By: apommier +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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 # include @@ -40,8 +41,8 @@ class vector typedef const T* const_pointer; typedef ft::random_access_iterator iterator; typedef ft::random_access_iterator const_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; + typedef ft::reverse_iterator reverse_iterator; + typedef ft::reverse_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 + friend bool operator== (const vector& lhs, const vector& rhs); + template + friend bool operator!= (const vector& lhs, const vector& rhs); + template + friend bool operator< (const vector& lhs, const vector& rhs); + template + friend bool operator<= (const vector& lhs, const vector& rhs); + template + friend bool operator> (const vector& lhs, const vector& rhs); + template + friend bool operator>= (const vector& lhs, const vector& rhs); + //--------------------------------------------- //---------OPERATOR OVERLOAD FUNCTION---------- //--------------------------------------------- @@ -491,5 +523,57 @@ class vector // } }; + template + bool operator== (const vector& lhs, const vector& 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 + bool operator!= (const vector& lhs, const vector& rhs) + { + return (!(lhs == rhs)); + } + + template + bool operator< (const vector& lhs, const vector& 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 + bool operator<= (const vector& lhs, const vector& rhs) + { + return (!(rhs < lhs)); + } + + template + bool operator> (const vector& lhs, const vector& rhs) + { + return (rhs < lhs); + } + + template + bool operator>= (const vector& lhs, const vector& rhs) + { + return (!(lhs < rhs)); + } + + } #endif \ No newline at end of file