From 84b8cd74d206cf7e0aac85d4833c754f627a4127 Mon Sep 17 00:00:00 2001 From: Charles Date: Fri, 24 Apr 2020 16:19:51 +0200 Subject: Vector draft all but iterator --- Vector.hpp | 364 ++++++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 249 insertions(+), 115 deletions(-) diff --git a/Vector.hpp b/Vector.hpp index 0f21995..7d6b40b 100644 --- a/Vector.hpp +++ b/Vector.hpp @@ -1,128 +1,262 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* Vector.hpp :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/24 16:19:04 by charles #+# #+# */ +/* Updated: 2020/04/24 16:19:05 by charles ### ########.fr */ +/* */ +/* ************************************************************************** */ + #ifndef VECTOR_HPP # define VECTOR_HPP -# include - -# define GROWTH_FACTOR 1.5 - -typedef size_t size_type; +# include +# define FT_VECTOR_GROWTH_FACTOR 1.5 namespace ft { - template < class T, class Alloc = allocator > + template < typename T, typename Alloc = allocator > class vector { - typedef T value_type; - typedef T& reference; - - public: - // capacity - size_type size() const; - { - return size; - } - void resize (size_type n, value_type val = value_type()) - { - if (n < size) - { - for (int i = n; i < size; i++) - ~T(under[i]); - size = n; - return; - } - if (n > capacity) - grow(); - size_type prev_n; - for (prev_n = n; prev_n < size; prev_n++) - under[n] = val; - size = n; - } - size_type capacity() const - { - return capacity; - } - bool empty() const - { - return size == 0; - } - void reserve (size_type n) - { - if (n > capacity) - grow_to(n); - } - - // element access - reference operator[] (size_type n) - { - return under[n]; - } - reference at (size_type n) - { - if (n >= size) - raise std::out_of_range; - return under[n]; - } - reference front() - { - return under[0]; - } - reference back() - { - return under[size - 1]; - } - - // modifiers - template - void assign (InputIterator first, InputIterator last); - void assign (size_type n, const value_type& val); - void push_back (const value_type& val) - { - if (size >= capacity) - grow(); - under[size] = val; - size++; - } - void pop_back() - { - ~T(back()); - size--; - } - iterator insert (iterator position, const value_type& val) - { - - } - void insert (iterator position, size_type n, const value_type& val); - template - void insert (iterator position, InputIterator first, InputIterator last); - - - - - private: - T *under; - size_type size; - size_type capacity; - - void grow() - { - capacity *= GROWTH_FACTOR; - grow_to(capacity); - } - - void grow_to(size_type new_capacity) - { - T *under_copy = new T[capacity]; - for (int i = 0; i < capacity; i++) - under_copy[i] = under[i]; - delete [] under; - capacity = new_capacity; - under = new T[capacity]; - for (int i = 0; i < capacity; i++) - under[i] = under_copy[i]; - delete [] under_copy; - } + public: + typedef T value_type; + typedef Alloc allocator_type; + typedef typename allocator_type::reference reference; + typedef typename allocator_type::const_reference const_reference; + typedef typename allocator_type::pointer pointer; + typedef typename allocator_type::const_pointer const_pointer; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + explicit Vector(const allocator_type& alloc = allocator_type()) + : m_under(new value_type[0]), m_size(0), m_capacity(0) + {} + + explicit Vector(size_type n, + const value_type& val = value_type(), + const allocator_type& alloc = allocator_type()) + : m_under(new value_type[n]), m_size(n), m_capacity(n) + { + for (size_type i = 0; i < n; i++) + m_under[i] = val; + } + + template + Vector (InputIterator first, + InputIterator last, + const allocator_type& alloc = allocator_type()) + : m_under(new value_type[0]), m_size(0), m_capacity(0) + { + for (; first != last; first++) + push_back(*first); + } + + Vector (const Vector& x) + { + *this = x; + } + + Vector& operator=(const Vector& x) + { + if (this == &x) + return *this; + delete [] m_under; + m_capacity = x.m_capacity; + m_size = x.m_size; + m_under = new value_type[m_capacity]; + for (size_type i = 0; i < m_size; i++) + m_under[i] = x.m_under[i]; + return *this; + } + + ~Vector() + { + delete [] m_under; + } + + size_type size() const { return m_size; } + size_type max_size() const { return UINT_MAX; } + size_type capacity() const { return m_capacity; } + bool empty() const { return m_size == 0; } + + void resize(size_type n, value_type val = value_type()) + { + if (n == m_size) + return ; + if (n > m_size) + { + reserve(n); + for (; m_size < n; m_size++) + m_under[m_size] = val; + } + else + { + value_type* newUnder = new value_type[n]; + m_capacity = n; + m_size = n; + for (size_type i = 0; i < m_size; i++) + newUnder[i] = m_under[i]; + delete [] m_under; + m_under = newUnder; + } + } + + void reserve(size_type n) + { + if (m_capacity < 2) + m_capacity = 2; + while (m_capacity < n) + m_capacity *= FT_VECTOR_GROWTH_FACTOR; + value_type* newUnder = new value_type[m_capacity]; + for (size_type i = 0; i < m_size; i++) + newUnder[i] = m_under[i]; + delete [] m_under; + m_under = newUnder; + } + + reference operator[](size_type n) { return m_under[n]; } + const_reference operator[](size_type n) const { return m_under[n]; } + + reference at(size_type n) + { + if (n >= m_size) + throw std::out_of_range("vector::_M_range_check"); + return m_under[n]; + } + + const_reference at(size_type n) const + { + if (n >= m_size) + throw std::out_of_range("vector::_M_range_check"); + return m_under[n]; + } + + reference front() { return m_under[0]; } + const_reference front() const { return m_under[0]; } + reference back() { return m_under[m_size - 1]; } + const_reference back() const { return m_under[m_size - 1]; } + + template + void assign(InputIterator first, InputIterator last) + { + size_type count; + InputIterator copy; + copy = first; + count = 0; + for (; copy != last; copy++) + count++; + reserve(count); + for (size_type i = 0; first != last; first++, i++) + m_under[i] = *first; + } + + void assign(size_type n, const value_type& val) + { + reserve(n); + for (size_type i = 0; i < n; ++) + m_under[i] = val; + } + + void push_back(const value_type& val) + { + m_size++; + reserve(m_size); + m_under[m_size - 1] = val; + } + + void pop_back() + { + m_size--; + ~value_type(m_under[m_size]); + m_under[m_size] = value_type(); + } + + // insert + + // erase + + void swap(Vector& x) + { + value_type* tmpUnder = m_under; + size_type* tmpSize = m_size; + size_type* tmpCapacity = m_capacity; + + m_under = x.m_under; + m_size = x.m_size; + m_capacity = x.m_capacity; + + x.m_under = tmpUnder; + x.m_size = tmpSize; + x.m_capacity = tmpCapacity; + } + + void clear() + { + delete [] m_under; + m_under = new value_type[0]; + m_size = 0; + m_capacity = 0; + } + + private: + value_type* m_under; + size_type m_size; + size_type m_capacity; }; } +template +bool operator==(const Vector& lhs, const Vector& rhs) +{ + if (lhs.size() != rhs.size()) + return false; + for (Vector::size_type i = 0; i < lhs.size(); i++) + if (!(lhs[i] == rhs[i])) + return false; + return true; +} + +template +bool operator!=(const Vector& lhs, const Vector& rhs) +{ + return !(lhs == rhs); +} + +template +bool operator& lhs, const Vector& rhs) +{ + for (Vector::size_type i = 0; i < lhs.size() && i < rhs.size(); i++) + if (lhs[i] < rhs[i] && !(rhs[i] < lhs[i])) + return true; + return false; +} + +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); +} + +template +void swap(Vector& x, Vector& y) +{ + x.swap(y); +} + #endif -- cgit