C++ vector 常用成员函数的模拟实现

C++ vector 常用成员函数的模拟实现

1. vector 常用成员函数的模拟实现

2. vector 常用成员函数实现后的测试

#include <assert.h>
#include <iostream>
#include <string>
using std::cout;
using std::endl;
using std::string;

//自定义命名空间 wch
namespace wch {
    //vector 要支持不同类型元素，所以用模板
    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<int> v(10, 1);
        //如果无函数 vector(int n, const T& val = T())，
        //因为参数类型更匹配，会去调用 vector(InputIterator first, InputIterator last)
        
        ( n,  T& val = ()) { (n, val); }
        ( n,  T& val = ()) { (n, val); }

        
        {
             (first != last) {
                (*first);
                ++first;
            }
        }

        
        () {}

        
        ( vector<T>& v) {
            _start =  T[v.()];
            
            
            
             ( i = ; i < v.(); i++) {
                _start[i] = v._start[i];
            }
            _finish = _start + v.();
            _endofstorage = _start + v.();
        }

        
        

        {
            
            std::(_start, v._start);
            std::(_finish, v._finish);
            std::(_endofstorage, v._endofstorage);
        }

        
        vector<T>& =(vector<T> v) {
            (v);
             *;
        }

        ~() {
             (_start) {
                [] _start;
                _start = _finish = _endofstorage = ;
            }
        }

        {
            
             (n > ()) {
                
                
                 sz = ();
                T* tmp =  T[n];
                 (_start) {
                    
                    
                    
                     ( i = ; i < sz; i++) {
                        tmp[i] = _start[i];
                    }
                    [] _start;
                }
                _start = tmp;
                _finish = _start + sz;
                _endofstorage = _start + n;
            }
        }

        
        
        {
             (n < ()) {
                _finish = _start + n;
            }  {
                (n);
                
                 (_finish != _start + n) {
                    *_finish = val;
                    ++_finish;
                }
            }
        }

        {
            
            ((), x);
        }

        {
            (--());
        }

        {  _endofstorage - _start; }
        {  _finish - _start; }

        T& []( pos) {
            (pos < ());
             _start[pos];
        }

         T& []( pos)  {
            (pos < ());
             _start[pos];
        }

        
        {
            (pos >= _start && pos <= _finish);
             (_finish == _endofstorage) {
                 len = pos - _start;
                
                 newcapacity = () ==  ?  : () * ;
                (newcapacity);
                
                pos = _start + len;
            }
            iterator end = _finish - ;
             (end >= pos) {
                *(end + ) = *end;
                --end;
            }
            *pos = x;
            ++_finish;
             pos;
        }

        
        {
            (pos >= _start && pos < _finish);
            iterator it = pos + ;
             (it != _finish) {
                *(it - ) = *it;
                ++it;
            }
            --_finish;
             pos;
        }

    :
        
        iterator _start = ;
        iterator _finish = ;
        iterator _endofstorage = ;
    };

    {
         ( e : v) {
            cout << e << ;
        }
        cout << endl;
    }

    {
        vector<> v1;
        v();
        v();
        v();
        v();
        v();
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
         ( i = ; i < v(); i++) {
            v1[i]++;
        }
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
        (v1);
    }

    {
        vector<> v1;
        v();
        v();
        v();
        v();
        v();
        v();
        v();
        v();
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
        v(v(), );
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
        
        vector<>::iterator p = v() + ;
        
        
        
        v(p, );
        
        
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
    }

    {
        vector<> v1;
        v();
        v();
        v();
        v();
        v();
        v();
        v();
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
         it = v();
         (it != v()) {
             (*it %  == ) {
                it = v(it);
            }  {
                ++it;
            }
        }
        
        
        
        
        
        
        
        
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
    }

    {
        vector<> v;
        v.(, );
         ( e : v) {
            cout << e << ;
        }
        cout << endl;
         i = ;
         j = ();
        
         k = ();
        
    }

    {
        vector<> v;
        v.();
        v.();
        v.();
        v.();
        v.();
        ;
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
        vector<> v2;
        v(, );
        v1 = v2;
         ( e : v1) {
            cout << e << ;
        }
        cout << endl;
    }

    {
        vector<string> v;
        v.();
        v.();
        v.();
        v.();
        v.();
         (& e : v) {
            cout << e << ;
        }
        cout << endl;
        ;
         (& e : v1) {
            cout << e << ;
        }
        cout << endl;
    }

    {
        ;
        ;
        ;
         ( e : v) {
            cout << e << ;
        }
        cout << endl;
        ;
         ( e : v3) {
            cout << e << ;
        }
        cout << endl;
        ;
        ;
         ( e : v4) {
            cout << e << ;
        }
        cout << endl;
         a[] = { , , ,  };
        ;
         ( e : v5) {
            cout << e << ;
        }
        cout << endl;
    }
}

{
    
    
    
    
    
    
    wch::();
     ;
}