std::vector的核心框架接口的模拟实现bit::vector
# pragma once
# include <iostream>
# include <assert.h>
# include <string>
# include <algorithm>
# include <vector> using std:: cout;
using std:: endl; namespace bit
{ template < class T > class vector { public : typedef T* iterator; typedef const T* const_iterator; iterator begin ( ) { return _start; } iterator end ( ) { return _finish; } const_iterator begin ( ) const { return _start; } const_iterator end ( ) const { return _finish; } vector ( ) { } vector ( const vector< T> & v) { reserve ( v. capacity ( ) ) ; for ( auto & e : v) { push_back ( e) ; } } vector ( std:: initializer_list< T> il) { size_t n = il. size ( ) ; reserve ( n * sizeof ( T) ) ; for ( auto e : il) { push_back ( e) ; } } template < class InputIterator > vector ( InputIterator first, InputIterator last) { while ( first < last) { push_back ( * first) ; ++ first; } } vector ( size_t n, const T& val = T ( ) ) { resize ( n, val) ; } vector ( int n, const T& val = T ( ) ) { resize ( n, val) ; } void swap ( vector< T> v) { std:: swap ( _start, v. _start) ; std:: swap ( _finish, v. _finish) ; std:: swap ( _endofstorage, v. _endofstorage) ; } vector< T> & operator = ( vector< T> v) { swap ( v) ; } ~ vector ( ) { delete [ ] _start; _start= _finish = _endofstorage = nullptr ; } size_t size ( ) const { return _finish - _start; } T& operator [ ] ( size_t pos) { assert ( pos < size ( ) ) ; return _start[ pos] ; } const T& operator [ ] ( size_t pos) const { assert ( pos < size ( ) ) ; return _start[ pos] ; } size_t capacity ( ) const { return _endofstorage - _start; } void reserve ( size_t n) { if ( n > capacity ( ) ) { T* tmp = new T[ n] ; size_t old_size = size ( ) ; for ( size_t i = 0 ; i < old_size; i++ ) { tmp[ i] = _start[ i] ; } delete [ ] _start; _start = tmp; _finish = tmp + old_size; _endofstorage = tmp + n; } } void resize ( size_t n, const T& val = T ( ) ) { if ( n > size ( ) ) { reserve ( n) ; while ( _finish < _start + n) { * _finish = val; ++ _finish; } } else { _finish = _start + n; } } void push_back ( const T& val) { insert ( _finish, val) ; } void pop_back ( ) { erase ( -- end ( ) ) ; } bool empty ( ) { return _start== _finish; } void insert ( iterator pos, const T& val) { assert ( pos >= _start) ; assert ( pos <= _finish) ; if ( size ( ) == capacity ( ) ) { size_t len = pos - _start; reserve ( capacity ( ) == 0 ? 4 : 2 * capacity ( ) ) ; pos = _start + len; } iterator it = _finish - 1 ; while ( it >= pos) { * ( it + 1 ) = * it; -- it; } * pos = val; ++ _finish; } iterator erase ( iterator pos) { assert ( pos >= _start) ; assert ( pos < _finish) ; iterator it = pos + 1 ; while ( it < _finish - 1 ) { * it = * ( it + 1 ) ; it++ ; } -- _finish; return pos; } private : iterator _start= nullptr ; iterator _finish= nullptr ; iterator _endofstorage= nullptr ; } ; template < class T > void print_vector ( const vector< T> & v) { for ( int i = 0 ; i < v. size ( ) ; i++ ) { cout << v[ i] << " " ; } cout << endl; }
}