first insert ok

templates/vector.tpp

@@ -37,6 +37,7 @@ VT_TPL template <class InputIterator> VT::
 	assign(first, last);
 	return;
 }
+// copy constructor --------------------------
 VT_TPL VT::
 	vector( vector const & src ) {
 
@@ -50,15 +51,19 @@ VT_TPL VT::
 VT_TPL VT & VT::
 	operator=( vector const & rhs ) {
 
+	vector	new_vector;
+
 	//Base::operator=(rhs);
 	if ( this != &rhs )
 	{
-		_size = rhs.size();
+		new_vector.reserve(_capacity);
+		new_vector.assign(rhs.begin(), rhs.end());
+		swap(new_vector);
+		//_size = rhs.size();
 	}
 	return *this;
 }
 
-
 /*********************************************
  * PUBLIC MEMBER FUNCTIONS
  *********************************************/
@@ -69,17 +74,23 @@ VT_TPL VT & VT::
 // begin -------------------------------------
 VT_TPL typename VT::iterator VT::
 	begin() { return _mem_ptr; }
-//const_iterator			begin() const;
+VT_TPL typename VT::const_iterator VT::
+	begin() const { return _mem_ptr; }
 // end ---------------------------------------
 VT_TPL typename VT::iterator VT::
 	end() { return &_mem_ptr[_size]; }
-//const_iterator			end() const;
+VT_TPL typename VT::const_iterator VT::
+	end() const { return &_mem_ptr[_size]; }
 // rbegin ------------------------------------
-//reverse_iterator		rbegin();
-//const_reverse_iterator	rbegin() const;
+//VT_TPL typename VT::reverse_iterator VT::
+//	rbegin() { return reverse_iterator(end()); }
+//VT_TPL typename VT::const_reverse_iterator VT::
+//	rbegin() const { return const_reverse_iterator(end()); }
 // rend --------------------------------------
-//reverse_iterator		rend();
-//const_reverse_iterator	rend() const;
+//VT_TPL typename VT::reverse_iterator VT::
+//	rend() { return reverse_iterator(begin()); }
+//VT_TPL typename VT::const_reverse_iterator VT::
+//	rend() const { return const_reverse_iterator(begin()); }
 
 	/************
 	 * capacity :
@@ -234,21 +245,108 @@ VT_TPL void VT::
 VT_TPL void VT::
 	pop_back() { _allocator.destroy(end() - 1); _size--; }
 // 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);
+VT_TPL typename VT::iterator VT::
+	insert(iterator position, const value_type& val) {
+
+	difference_type	distance;
+	iterator		it;
+
+	if (_size + 1 > _capacity)
+	{
+		distance = position - begin();
+		_increment_capacity(1);
+		position = begin() + distance;
+	}
+	it = end();
+	if (position != it)
+	{
+		_allocator.construct(it, *(it - 1));
+		while (--it != position)
+			*(it + 1) = *it;
+	}
+	_allocator.destroy(position);
+	_allocator.construct(position, val);
+	_size++;
+	return (position);
+}
+//VT_TPL void VT::
+//	insert(iterator position, size_type n, const value_type& val) {
+//
+//}
+//VT_TPL template <class InputIterator> void VT::
+//	insert(iterator position, InputIterator first, InputIterator last) {
+//
+//}
 // erase -------------------------------------
-//iterator	erase(iterator position);
-//iterator	erase(iterator first, iterator last);
+VT_TPL typename VT::iterator VT::
+	erase(iterator position) {
+
+	iterator	i = position;
+	iterator	it_end = end() - 1;
+
+	while (i != it_end)
+	{   
+		*i = *(i + 1);
+		++i;
+	}
+	_allocator.destroy(it_end);
+	_size -= 1;
+	return (position);
+}
+VT_TPL typename VT::iterator VT::
+	erase(iterator first, iterator last) {
+
+	iterator		it_end = end();
+	difference_type	diff = std::distance(first, last);
+
+	if (diff <= 0)
+		return (first);
+
+	it_end = end();
+	while (last != it_end)
+	{
+		*first = *last;
+		first++;
+		last++;
+	}
+	_destroy(it_end - diff, it_end);
+	_size -= diff;
+
+	return (first);
+}
 // swap --------------------------------------
-//void		swap(vector& x);
+VT_TPL void VT::
+	swap(vector& x) {
+
+	T*			tmp_mem_ptr;
+	size_type	tmp_size;
+	size_type	tmp_capacity;
+
+	tmp_mem_ptr = x._mem_ptr;
+	tmp_size = x._size;
+	tmp_capacity = x._capacity;
+
+	x._mem_ptr = _mem_ptr;
+	x._size = _size;
+	x._capacity = _capacity;
+
+	_mem_ptr = tmp_mem_ptr;
+	_size = tmp_size;
+	_capacity = tmp_capacity;
+}
 // clear -------------------------------------
 VT_TPL void VT::
 	clear() { _destroy(begin(), end()); _size = 0; }
 
 
 
+/*************
+ * allocator :
+ *************/
+// get_allocator -----------------------------
+VT_TPL typename VT::allocator_type VT::
+	get_allocator() const { return (_allocator); }
+
 
 /*********************************************
  * PRIVATE MEMBER FUNCTIONS