STL之vector的实现

"vector.h"#pragma warning(disable : 4996)#include"Allocator.h"#include"uninitialized.h"#include<algorithm>#include<exception>template<class T, class Alloc = alloc>class vector{public:typedef T value_type;typedef value_type* pointer;typedef value_type& reference;typedef size_t size_type;typedef ptrdiff_t difference;typedef value_type* iterator;protected:typedef simple_alloc<value_type, Alloc> data_allocator;iterator start;iterator finish;iterator end_of_storage;void insert_aux(iterator position, const T& x);void deallocate(){if (start)data_allocator::deallocate(start, end_of_storage - start);}void fill_initialize(size_type n, const T& value){start = allocate_and_fill(n, value);finish = start + n;end_of_storage = finish;}public:iterator begin()const{ return start; }iterator end()const{ return finish; }size_type size()const { return size_type(end() - begin()); }size_type capacity()const { return size_type(end_of_storage - begin()); }bool empty()const{ return begin() == end(); }reference operator[](size_type n){ return *(begin() + n); }void insert(iterator position, size_type n, const T& x);vector() :start(0), finish(0), end_of_storage(0){}vector(size_type n, const T& value){ fill_initialize(n, value); }vector(int n, const T& value){ fill_initialize(n, value); }vector(long n, const T& value){ fill_initialize(n, value); }explicit vector(size_type n){ fill_initialize(n, T()); }~vector(){destroy(start, finish);deallocate();}reference front(){ return *begin(); }reference back(){ return *(end() - 1); }void pop_back(){--finish;destroy(finish);}void push_back(const T& x){if (finish != end_of_storage){construct(finish, x);++finish;}elseinsert_aux(end(), x);}iterator erase(iterator position){if (position + 1 != end())copy(position + 1, finish, position);--finish;destroy(finish);return position;}void resize(size_type new_size, const T& x){if (new_size < size())erase(begin() + new_size, end());elseinsert(end(), new_size - size(), x);}void resize(size_type new_size){resize(new_size, T());}void clear(){erase(begin(), end());}protected:iterator allocate_and_fill(size_type n, const T& value){iterator result = data_allocator::allocate(n);myuninitialized_fill_n(result, n, value);return result;}};template<class T, class Alloc>void vector<T, Alloc>::insert_aux(iterator position, const T& x){if (finish != end_of_storage){construct(finish, *(finish - 1));++finish;T x_copy = x;copy_backward(position, finish - 2, finish - 1);*position = x_copy;}else{const size_type old_size = size();const size_type len = old_size != 0 ? 2 * old_size : 1;iterator new_start = data_allocator::allocate(len);iterator new_finish = new_start;try{new_finish = uninitialized_copy(start, position, new_start);construct(new_finish, x);++new_finish;new_finish = uninitialized_copy(position, finish, new_finish);}catch(...){destroy(new_start, new_finish);data_allocator::deallocate(new_start, len);throw;}destroy(begin(), end());deallocate();start = new_start;finish = new_finish;end_of_storage = new_start + len;}}template<class T,class Alloc>void vector<T, Alloc>::insert(iterator position, size_type n, const T& x){if (n != 0){if (size_type(end_of_storage - finish) >= n){T x_copy = x;const size_type elems_after = finish - position;iterator old_finish = finish;if (elems_after > n){uninitialized_copy(finish - n, finish, finish);finish += n;copy_backward(position, old_finish - n, old_finish);fill(position, position + n, x_copy);}else{uninitialized_fill_n(finish, n - elems_after, x_copy);finish += n - elems_after;uninitialized_copy(position, old_finish, finish);finish += elems_after;fill(position, old_finish, x_copy);}}else{const size_type old_size = size();const size_type len = old_size + max(old_size, n);iterator new_start = data_allocator::allocate(len);iterator new_finish = new_start;try{new_finish = uninitialized_copy(start, position, new_start);new_finish = uninitialized_fill_n(new_finish, n, x);new_finish = uninitialized_copy(position, finish, new_finish);}catch (...){destroy(new_start, new_finish);data_allocator::deallocate(new_start, len);throw;}destroy(start, finish);deallocate();start = new_start;finish = new_finish;end_of_storage = new_start + len;}}}"type_traits.h"struct __true_type{};struct __false_type{};template<class type>struct __type_traits{typedef __true_type this_dummy_member_must_be_first;typedef __false_type has_trivial_default_constructor;typedef __false_type has_trivial_copy_constructor;typedef __false_type has_trivial_assignment_operator;typedef __false_type has_trivial_destructor;typedef __false_type is_POD_type;};template<>struct __type_traits<int>{typedef __true_type this_dummy_member_must_be_first;typedef __true_type has_trivial_default_constructor;typedef __true_type has_trivial_copy_constructor;typedef __true_type has_trivial_assignment_operator;typedef __true_type has_trivial_destructor;typedef __true_type is_POD_type;};"iterator_traits.h"class input_iterator_tag_h{};class output_iterator_tag_h{};class forward_iterator_tag_h : public input_iterator_tag_h{};class bidirectional_iterator_tag_h : public forward_iterator_tag_h{};class random_access_iterator_tag_h : public bidirectional_iterator_tag_h{};template<class Category, class T, class Distance = ptrdiff_t, class Pointer = T*, class Reference = T&>class iterator{typedef Category iterator_category;typedef Distance difference_type;typedef T value_type;typedef Pointer pointer;typedef Reference reference;};template<class I>class iterator_trait{public:typedef typename I::iterator_category iterator_category;typedef typename I::difference_type differene_type;typedef typename I::value_type value_type;typedef typename I::pointer pointer;typedef typename I::reference reference;};template<class T>class iterator_trait<T*>{public:typedef random_access_iterator_tag_h iterator_category;typedef T value_type;typedef T* pointer;typedef T& reference;typedef ptrdiff_t difference_type;};template<class T>class iterator_trait<const T*>{public:typedef random_access_iterator_tag_h iterator_category;typedef T value_type;typedef const T* pointer;typedef const T& reference;typedef ptrdiff_t difference_type;};template<class Iterator>inline typename iterator_trait<Iterator>::iterator_category iterator_category(const Iterator&){typedef typename iterator_trait<Iterator>::iterator_category category;return category();}template<class Iterator>inline typename iterator_trait<Iterator>::value_type* value_type(const Iterator&){return static_cast<typename iterator_trait<Iterator>::value_type*>(0);}template<class Iterator>inline typename iterator_trait<Iterator>::difference_type* distance_type(const Iterator&){return static_cast<typename iterator_trait<Iterator>::difference*>(0);}template<class InputIterator, class Distance>inline void advance(InputIterator& i, Distance n){__advance(i, n, iterator_trait<InputIterator>::iterator_category());}template<class InputIterator, class Distance>inline void __advance(InputIterator& i, Distance n, input_iterator_tag_h){while (n--)++i;}template<class InputIterator, class Distance>inline void __advance(InputIterator& i, Distance n, forward_iterator_tag_h){__advance(i, n, input_iterator_tag());}template<class InputIterator, class Distance>inline void __advance(InputIterator& i, Distance n, bidirectional_iterator_tag_h){if (n >= 0)while (n--)++i;elsewhile (n++)--i;}template<class InputIterator, class Distance>inline void __advance(InputIterator& i, Distance n, random_access_iterator_tag_h){i += n;}template<class InputIterator>inline typename iterator_trait<InputIterator>::differene_type distance(InputIterator first, InputIterator last){typedef typename iterator_trait<InputIterator>::iterator_category category;return __distance(first, last, category());}template<class InputIterator>inline typename iterator_trait<InputIterator>::differene_type __distance(InputIterator first, InputIterator last, input_iterator_tag_h){iterator_trait<InputIterator>::difference_type n = 0;while (first != last){++n;++first;}return n;}template<class InputIterator>inline typename iterator_trait<InputIterator>::differene_type __distance(InputIterator first, InputIterator last, random_access_iterator_tag_h){return last - first;}#include<new>#include"type_traits.h"#include"iterator_traits.h"template<class T1, class T2>inline void construct(T1* p, const T2& value){new (p)T1(value);}template<class T>inline void destroy(T* pointer){pointer->~T();}template<class ForwardIterator>inline void destroy(ForwardIterator first, ForwardIterator last){__destroy(first, last, value_type(first));}template<class ForwardIterator, class T>inline void __destroy(ForwardIterator first, ForwardIterator last, T*){typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;__destroy_aux(first, last, trivial_destructor());}template<class ForwardIterator>inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type){for (; first != last; ++first)destroy(&*first);}template<class ForwardIterator>inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __true_type){}inline void destroy(char*, char*){}inline void destroy(wchar_t*, wchar_t*){}#include"vector.h"#include<iostream>using namespace std;int main(){vector<int> v(9, 2);cout << v.size() << endl;cout << v.capacity() << endl;for (int i = 0; i < 9; i++)cout << v[i] << " ";cout << endl;v.pop_back();v.pop_back();v.push_back(3);v.push_back(4);v.push_back(5);v.push_back(6);cout << v.size() << endl;cout << v.capacity() << endl;for (int i = 0; i < v.size(); i++)cout << v[i] << " ";cout << endl;vector<int>::iterator pos = find(v.begin(), v.end(), 4);cout << *pos << endl;v.insert(pos, 10, 10);cout << v.size() << endl;cout << v.capacity() << endl;for (int i = 0; i < v.size(); i++)cout << v[i] << " ";}