42/42_INT_11_ft_containers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix push_back reserve growth

Browse Source
This commit is contained in:
hugogogo
2022-06-03 19:49:09 +02:00
parent 7d857c5e4e
commit 556807669e
3 changed files with 125 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
templates/vector.tpp
View File

@@ -1,7 +1,6 @@
//#include "vector.hpp"
#define COPLIEN_COLOR B_CYAN
#define VT_TPL template <class T, class Allocator>
#define VT vector<T, Allocator>
namespace ft {
@@ -9,39 +8,41 @@ namespace ft {
* CONSTRUCTORS
*********************************************/
// template <class InputIterator>
// vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
template <class T, class Allocator>
vector<T, Allocator>::
VT_TPL VT::
vector( const Allocator & alloc )
: _size(0)
, _capacity(0)
, _mem_ptr(NULL)
, _allocator(alloc)
{
// std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
return;
}
template <class T, class Allocator>
vector<T, Allocator>::
VT_TPL VT::
vector( size_type n, const T & val, const Allocator & alloc )
: _size(0)
, _capacity(0)
, _mem_ptr(NULL)
, _allocator(alloc)
{
// std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
assign(n, val);
return;
}
template <class T, class Allocator>
vector<T, Allocator>::
VT_TPL template <class InputIterator> VT::
vector(InputIterator first, InputIterator last, const Allocator & alloc)
: _size(0)
, _capacity(0)
, _mem_ptr(NULL)
, _allocator(alloc)
{
assign(first, last);
return;
}
VT_TPL VT::
vector( vector const & src )
{
// std::cout << COPLIEN_COLOR "vector copy constructor" RESET "\n";
*this = src;
return;
}
@@ -50,11 +51,9 @@ vector( vector const & src )
* DESTRUCTORS
*********************************************/
template <class T, class Allocator>
vector<T, Allocator>::
VT_TPL VT::
~vector()
{
// std::cout << COPLIEN_COLOR "vector destructor" RESET "\n";
return;
}
@@ -62,8 +61,7 @@ vector<T, Allocator>::
* OPERATORS
*********************************************/
template <class T, class Allocator>
vector<T, Allocator> & vector<T, Allocator>::
VT_TPL VT & VT::
operator=( vector const & rhs )
{
// Base::operator=(rhs);
@@ -89,46 +87,44 @@ operator=( vector const & rhs )
* iterators :
*************/
// begin -------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::iterator vector<T, Allocator>::
begin()
{
return _mem_ptr;
}
VT_TPL typename VT::iterator VT::
begin() { return _mem_ptr; }
//const_iterator begin() const;
// end ---------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::iterator vector<T, Allocator>::
end()
{
return &_mem_ptr[_size];
}
VT_TPL typename VT::iterator VT::
end() { return &_mem_ptr[_size]; }
//const_iterator end() const;
// rbegin ------------------------------------
//reverse_iterator rbegin();
//const_reverse_iterator rbegin() const;
// rend --------------------------------------
//reverse_iterator rend();
//const_reverse_iterator rend() const;
/************
* capacity :
************/
// size --------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::size_type vector<T, Allocator>::
size( ) const
VT_TPL typename VT::size_type VT::
size( ) const
{
return _size;
}
// max_size ----------------------------------
//size_type max_size() const;
// resize ------------------------------------
//void resize(size_type n, value_type val = value_type());
// capacity ----------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::size_type vector<T, Allocator>::
capacity() const
VT_TPL typename VT::size_type VT::
capacity() const
{
return _capacity;
}
// empty -------------------------------------
//bool empty() const;
// reserve -----------------------------------
template <class T, class Allocator>
void vector<T, Allocator>::
reserve( size_type new_cap )
VT_TPL void VT::
reserve( size_type new_cap )
{
value_type * tmp_ptr;
@@ -158,23 +154,44 @@ reserve( size_type new_cap )
* element access :
******************/
// operator[] --------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::reference vector<T, Allocator>::
operator[](size_type n)
{
return _mem_ptr[n];
}
VT_TPL typename VT::reference VT::
operator[](size_type n) { return _mem_ptr[n]; }
//const_reference operator[](size_type n) const;
// at ----------------------------------------
//reference at(size_type n);
//const_reference at(size_type n) const;
// front -------------------------------------
//reference front();
//const_reference front() const;
// back --------------------------------------
//reference back();
//const_reference back() const;
/*************
* modifiers :
*************/
// assign ------------------------------------
template <class T, class Allocator>
void vector<T, Allocator>::
assign( size_type n, const T & val )
VT_TPL template <class InputIterator> void VT::
assign( InputIterator first, InputIterator last)
{
InputIterator tmp = first;
int range;
clear();
for (range = 1; tmp != last; range++)
tmp++;
_size += range;
if (_size >= _capacity)
reserve(_size);
while (first != last)
{
_allocator.construct(&_mem_ptr[_size], first);
first++;
}
}
VT_TPL void VT::
assign( size_type n, const T & val )
{
if (n > _allocator.max_size())
throw std::length_error("assign: n > max_size");
@@ -195,20 +212,38 @@ assign( size_type n, const T & val )
_allocator.construct(&_mem_ptr[--n], val);
}
// push_back ---------------------------------
template <class T, class Allocator>
void vector<T, Allocator>::
push_back( const value_type & element )
VT_TPL void VT::
push_back( const value_type & element )
{
if (_size >= _capacity)
reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
{
if (_size == 0)
reserve(1);
else
reserve(std::min(_size * 2, _allocator.max_size()));
}
_allocator.construct(&_mem_ptr[_size], element);
_size++;
}
// pop_back ----------------------------------
//void pop_back();
// insert ------------------------------------
//iterator insert(iterator position, const value_type& val);
//void insert(iterator position, size_type n, const value_type& val);
//template <class InputIterator>
// void insert(iterator position, InputIterator first, InputIterator last);
// erase -------------------------------------
//iterator erase(iterator position);
//iterator erase(iterator first, iterator last);
// swap --------------------------------------
//void swap(vector& x);
// clear -------------------------------------
VT_TPL void VT::
clear()
{
_destroy(begin(), end());
_size = 0;
}
@@ -217,9 +252,8 @@ push_back( const value_type & element )
* PRIVATE MEMBER FUNCTIONS
*********************************************/
template <class T, class Allocator>
void vector<T, Allocator>::
_destroy(iterator first, iterator last)
VT_TPL void VT::
_destroy(iterator first, iterator last)
{
while (first != last)
{
@@ -240,4 +274,7 @@ _destroy(iterator first, iterator last)
//std::string const vector::_bar = "bar";
}
} // namespace ft
#undef VT
#undef VT_TPL