386 lines
7.5 KiB
C++
386 lines
7.5 KiB
C++
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* vector.hpp :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2022/10/12 19:46:32 by apommier #+# #+# */
|
|
/* Updated: 2022/11/14 06:50:18 by apommier ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#ifndef VECTOR_HPP
|
|
# define VECTOR_HPP
|
|
|
|
# include "./iterators/random_access_iterator.hpp"
|
|
|
|
namespace ft
|
|
{
|
|
|
|
template< class T, class Allocator = std::allocator<T> >
|
|
class vector
|
|
{
|
|
public:
|
|
//-----------------------------
|
|
//---------MEMBER TYPE---------
|
|
//-----------------------------
|
|
typedef T value_type;
|
|
typedef Allocator allocator_type;
|
|
typedef value_type& reference;
|
|
typedef const value_type& const_reference;
|
|
typedef T* pointer;
|
|
typedef const T* const_pointer;
|
|
typedef ft::random_access_iterator<value_type> iterator;
|
|
typedef const ft::random_access_iterator<value_type> const_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef std::size_t size_type;
|
|
|
|
|
|
//-----------------------------
|
|
//-----PRIVATE MEMBER TYPE-----
|
|
//-----------------------------
|
|
private:
|
|
|
|
value_type *_tab;
|
|
size_type _size;
|
|
size_type _capacity;
|
|
|
|
allocator_type _alloc;
|
|
ft::random_access_iterator<value_type> _end;
|
|
ft::random_access_iterator<value_type> _start;
|
|
|
|
//pointer _end_capacity;
|
|
|
|
public:
|
|
|
|
//---------------------------------------
|
|
//---------COPLIEN FORM FUNCTION---------
|
|
//---------------------------------------
|
|
explicit vector (const allocator_type& alloc = allocator_type()) : _alloc(alloc) //default constructor
|
|
{
|
|
_tab = 0;
|
|
_size = 0;
|
|
_capacity = 0;
|
|
//_start = 0;
|
|
//_end = 0;
|
|
|
|
|
|
_alloc = alloc;
|
|
_start = _alloc.allocate(0);
|
|
_end = _start;
|
|
}
|
|
|
|
explicit vector (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()): _alloc(alloc) //fill constructor
|
|
{
|
|
_tab = 0;
|
|
_size = 0;
|
|
_capacity = 0;
|
|
|
|
_alloc = alloc;
|
|
_tab = _alloc.allocate(n);
|
|
_start = _tab;
|
|
_size = n;
|
|
_capacity = n;
|
|
_end = _start + n;
|
|
while (n--)
|
|
_alloc.construct(_tab + n, val);
|
|
//_end = _start;
|
|
//_start + 5;
|
|
///5 + _start;
|
|
}
|
|
|
|
//template <class InputIterator>
|
|
//vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()) //range constructor
|
|
//{
|
|
|
|
//}
|
|
|
|
vector (const vector& x)//copy constructor
|
|
{
|
|
|
|
}
|
|
|
|
~vector()
|
|
{
|
|
|
|
}
|
|
|
|
vector& operator= (const vector& x)//assignation operator
|
|
{
|
|
|
|
}
|
|
|
|
//----------------------------------
|
|
//---------MEMBER FUNCTION----------
|
|
//----------------------------------
|
|
|
|
//-------------------------
|
|
//--------Iterators--------
|
|
//-------------------------
|
|
iterator begin()
|
|
{
|
|
return (_start);
|
|
}
|
|
|
|
iterator end()
|
|
{
|
|
return (_end);
|
|
}
|
|
|
|
reverse_iterator rbegin()
|
|
{
|
|
return (_end);
|
|
}
|
|
|
|
reverse_iterator rend()
|
|
{
|
|
return (_start);
|
|
}
|
|
|
|
//------------------------
|
|
//--------Capacity--------
|
|
//------------------------
|
|
size_type size() const
|
|
{
|
|
return (_end - _start);
|
|
}
|
|
|
|
size_type max_size() const
|
|
{
|
|
return (_alloc.max_size());
|
|
}
|
|
|
|
void resize (size_type n, value_type val = value_type()) //Resizes the container so that it contains n elements.
|
|
{
|
|
if (n > this->max_size())
|
|
throw (std::length_error("vector::resize"));
|
|
else if (n < this->size())
|
|
{
|
|
while (n > this->size())
|
|
{
|
|
_end--;
|
|
_alloc.destroy(_end);
|
|
}
|
|
}
|
|
//else // n > size
|
|
//insert()
|
|
}
|
|
|
|
size_type capacity() const
|
|
{
|
|
return (_capacity);
|
|
}
|
|
|
|
bool empty() const
|
|
{
|
|
if (_end == _start)
|
|
return (1);
|
|
return(0);
|
|
}
|
|
|
|
void reserve (size_type n)
|
|
{
|
|
|
|
}
|
|
|
|
//------------------------------
|
|
//--------Element access--------
|
|
//------------------------------
|
|
reference operator[] (size_type n)
|
|
{
|
|
return (_tab[n]);
|
|
}
|
|
|
|
const_reference operator[] (size_type n) const
|
|
{
|
|
return (_tab[n]);
|
|
}
|
|
|
|
reference at (size_type n)
|
|
{
|
|
//exception
|
|
return (_tab[n]);
|
|
}
|
|
|
|
const_reference at (size_type n) const
|
|
{
|
|
//exception
|
|
return (_tab[n]);
|
|
}
|
|
|
|
reference front()
|
|
{
|
|
return (*_start);
|
|
}
|
|
|
|
const_reference front() const
|
|
{
|
|
return (*_start);
|
|
}
|
|
|
|
reference back()
|
|
{
|
|
return (*_end);
|
|
}
|
|
|
|
const_reference back() const
|
|
{
|
|
return (*_end);
|
|
}
|
|
|
|
value_type* data()
|
|
{
|
|
return (_start);
|
|
}
|
|
|
|
const value_type* data() const
|
|
{
|
|
return (_start);
|
|
}
|
|
|
|
//-------------------------
|
|
//--------Modifiers--------
|
|
//-------------------------
|
|
template <class InputIterator>
|
|
void assign (InputIterator first, InputIterator last) //range
|
|
{
|
|
|
|
}
|
|
|
|
void assign (size_type n, const value_type& val) //fill
|
|
{
|
|
|
|
this->clear();
|
|
if (n > this->max_size())
|
|
throw (std::length_error("vector::resize"));
|
|
else if (n < this->size())
|
|
{
|
|
while (n > this->size())
|
|
{
|
|
_end--;
|
|
_alloc.destroy(_end);
|
|
}
|
|
}
|
|
//else // n > size
|
|
//insert()
|
|
}
|
|
|
|
void push_back (const value_type& val)
|
|
{
|
|
//if (!this->max_size() - _size)
|
|
// ;
|
|
//throw or alloc
|
|
//else
|
|
//{
|
|
_alloc.construct(_end.getPointer() - 2, val);
|
|
_size++;
|
|
_end++;
|
|
//}
|
|
}
|
|
|
|
void pop_back()
|
|
{
|
|
//if (!_size)
|
|
// ;
|
|
//throw std::;
|
|
_alloc.destroy(_end - 1);
|
|
_end--;
|
|
_size--;
|
|
}
|
|
|
|
iterator insert (iterator position, const value_type& val) //single element
|
|
{
|
|
|
|
}
|
|
|
|
void insert (iterator position, size_type n, const value_type& val) //fill
|
|
{
|
|
|
|
}
|
|
|
|
template <class InputIterator>
|
|
void insert (iterator position, InputIterator first, InputIterator last) //range
|
|
{
|
|
|
|
}
|
|
|
|
iterator erase (iterator position)
|
|
{
|
|
|
|
}
|
|
|
|
iterator erase (iterator first, iterator last)
|
|
{
|
|
|
|
}
|
|
|
|
void swap (vector& x)
|
|
{
|
|
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
int i = 0;
|
|
|
|
while (_start != _end)
|
|
this->pop_back();
|
|
}
|
|
|
|
//-------------------------
|
|
//--------Allocator--------
|
|
//-------------------------
|
|
allocator_type get_alloc() const
|
|
{
|
|
return (_alloc);
|
|
}
|
|
|
|
//---------------------------------------------
|
|
//---------OPERATOR OVERLOAD FUNCTION----------
|
|
//---------------------------------------------
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator< (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator> (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
// template <class T, class Alloc>
|
|
// bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
|
|
// {
|
|
|
|
// }
|
|
|
|
|
|
|
|
};
|
|
|
|
}
|
|
#endif |