Kinou/ft_containers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reverse iterator almost done

Browse Source
This commit is contained in:
kinou-p 2022-11-22 06:16:48 +01:00
parent 435dac1965
commit 9656f9e55a
3 changed files with 235 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
containers/iterators/random_access_iterator.hpp
View File

@ -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 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<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

106
containers/iterators/reverse_iterator.hpp
View File

@ -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
# define REVERSE_ITERATOR_HPP
#pragma once
# include <cstddef>
# include "./iterator_traits.hpp"
namespace ft
{
@ -28,10 +28,10 @@ namespace ft
typedef typename ft::iterator_traits<Iter>::difference_type difference_type;
typedef typename ft::iterator_traits<Iter>::pointer pointer;
typedef typename ft::iterator_traits<Iter>::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<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); }
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<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); }
};
}

104
containers/vector.hpp
View File

@ -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 std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ft::reverse_iterator<iterator> 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