//Vector(容器)模拟实现
namespace UC
{
  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(size_t n, const T& val= T())
    {
      resize(n, val);
    }
    
    //拷贝构造 ---->第一种写法
    vector(const T& v)
    {
      _start = new T[v.capacity()];
      
      //此处涉及到 浅拷贝， 会使得程序发生崩溃 ！
      //memcpy(_start, v._start, sizeof(T) * v.size());
      
      //正确拷贝 赋值行为
      for(size_t i = 0; i < v.size(); i++)
      {
      	_start[i] = v._start[i];
      }
      
      _finish = _start + v.size();
      _endofstorge = _start + v.capacity();
    }
    
    //拷贝构造 ---->第二种写法
    vector(const T& v)
    {
    	reserve(v.capacity());
      for(auto e : v)
      {
      	  v.push_back(e);
      }
    }
    //多参数构造 ---->难点理解
    vector(size_t n, const T& val = T())
    {
    	resize(n, val);
    }
    vector(int n, const T& val = T())
    {
    	resize(n, val);
    }
    template<class InputIterator> //模板内可以再套用一个模板
    vector(InputIterator first, InputIterator last)
    {
    	while(first != last)
      {
      	push_back(*first);
        ++first;
      }
    }
    //扩容
    void reserve(size_t n)
    {
    	if(n > capacity())
      {
        size_t sz = size(); //注意 :>此处需要保存数值---->难点
        T* tamp = new T[n];
        
      	if(_start)
        {
          //此处涉及到 浅拷贝， 致使程序运行会发生错误
          ///memcpy(tamp, _start, sizeof(T) * sz);
          
          //正确拷贝赋值行为
          for(size_t i = 0; i < size(); i++)
          {
          	tamp[i] = _start[i];
          }
        	delete[] _start;
        }
        
        _start = tamp;
        _finish = _start + sz;
        _endofstoarge = _start + n;
      }
    }
    
    //追加数据
    void push_back(const T& x)
    {
    	insert(end(), x);
    }
    //插入数据
    iterator insert(iterator pos, const T& val)
    {
    	assert(pos >= _start && pos <= _finish);
      
      if(_finish == _endofstorge)
      {
      	size_t len = pos - _start;
        
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        
        reserve(newCapacity);
        
        pos = len + _start;
      }
        
        iterator end = _finish - 1;
        while(end >= pos)
        {
        	*(end + 1) = *end;
          --end;
        }
        
        *pos = val;
        ++_finish;
      
      return pos;
    }
    void resize(size_t n, const T& val = T())
    {
    	if(n < size())
      {
        _finish = _start + n;
      }
      else
      {
      	while(_finish != _start + n)
        {
        	*_finish = val;
          ++_finish;
        }
      }
    }
    
    size_t size() const
    {
    	return _finish - _start;
    }
    size_t capacity() const
    {
    	return _endofstorge - _start;
    }
    
    T& operator[](iterator pos)
    {
      assert(pos < size());
    	return _start[pos];
    }
    const T& operator[](iterator pos)
    {
      assert(pos < size());
    	return _start[pos];
    }
    ~vector()
    {
      delete[] _start;
      
      _start = _finish = _endofstorge = nullptr;
    }
  private:
    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _endofstorge = nullptr;
  }
}

//测试运行一组 ---->隐藏Bug

#include "Vector.h"

void test_01()
{
	UC :: vector<string> v1;
  
  v1.push_back("111111111111");
  v1.push_back("222222222222");
  v1.push_back("333333333333");
  
  for(auto e : v1)
  {
  	cout << e << " ";
  }
  cout << endl;
}

void test_02()
{
	UC :: vector<string> v1;
  
  v1.push_back("111111111111");
  v1.push_back("222222222222");
  v1.push_back("333333333333");
  
  v1.push_back("101010101010");
  v1.push_back("010101010101");
  
  for(auto= e : v1)
  {
    cout << e << " ";
  }
  cout << endl;
}

int man()
{
  test_0();
	return 0;
}