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

15
headers/vector.hpp
View File

@@ -33,9 +33,9 @@ public:
explicit vector (const allocator_type & alloc = allocator_type());
explicit vector (size_type n, const value_type& val = value_type(),
const allocator_type& alloc = allocator_type());
// template <class InputIterator>
// vector (InputIterator first, InputIterator last,
// const allocator_type& alloc = allocator_type());
template <class InputIterator>
vector (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
vector( vector const & src );
// destructor --------------------------------
~vector();
@@ -95,8 +95,8 @@ public:
* modifiers :
*************/
// assign ------------------------------------
//template <class InputIterator>
// void assign(InputIterator first, InputIterator last);
template <class InputIterator>
void assign(InputIterator first, InputIterator last);
void assign(size_type n, const value_type& val);
// push_back ---------------------------------
void push_back(const value_type & val);
@@ -113,7 +113,7 @@ public:
// swap --------------------------------------
//void swap(vector& x);
// clear -------------------------------------
//void clear();
void clear();
private:
@@ -129,9 +129,8 @@ private:
//std::ostream & operator<<(std::ostream & o, vector const & rhs);
}
} // namespace ft
# include "vector.tpp"
#endif

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

35
tests/main.cpp
View File

@@ -25,21 +25,21 @@ int main() {
size = myvector.size();
for (int i = 0; i < size; i++)
std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
std::cout << "\nsize :" << size << " , capacity :" << myvector.capacity() << "\n";
std::cout << "\nsize : " << size << " , capacity : " << myvector.capacity() << "\n";
std::cout << "\nassign 3\n";
myvector.assign(3, 12);
size = myvector.size();
for (int i = 0; i < size; i++)
std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
std::cout << "\nsize :" << size << " , capacity :" << myvector.capacity() << "\n";
std::cout << "\nsize : " << size << " , capacity : " << myvector.capacity() << "\n";
std::cout << "\nassign 7268\n";
myvector.assign(7268, 12);
size = myvector.size();
for (int i = 0; i < size; i++)
std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
std::cout << "\nsize :" << size << " , capacity :" << myvector.capacity() << "\n";
// std::cout << "\nassign 7268\n";
// myvector.assign(7268, 12);
// size = myvector.size();
// for (int i = 0; i < size; i++)
// std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << " - ";
// std::cout << "\nsize : " << size << " , capacity : " << myvector.capacity() << "\n";
}
TESTEND
@@ -337,17 +337,28 @@ int main() {
{
ft::vector<int> myvector;
// first test
int myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
int size = sizeof(myint) / sizeof(myint[0]);
for (int i = 0; i < size; i++)
{
myvector.push_back(myint[i]);
std::cout << "[capacity : "
<< std::setw(2) << myvector.capacity() << "] "
<< myvector[i] << "\n";
}
for (int i = 0; i < size; i++)
std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << "\n";
std::cout << " -> size : " << myvector.size() << " , capacity :" << myvector.capacity() << "\n";
std::cout << " -> myvector stores " << int(myvector.size()) << " numbers.\n";
// second test
// for (int i = 0; i < 72363; i++)
// {
// myvector.push_back(9);
// std::cout << "[" << i
// << ":" << myvector.capacity() << "] ";
// }
// std::cout << " -> size : " << myvector.size() << " , capacity :" << myvector.capacity() << "\n";
}
TESTEND