王者荣耀安卓区修改荣耀战区方法 | 最低战力查询（附带视频与安装包）

 安卓手机虚拟定位教程

安卓手机虚拟定位教程 (kdocs.cn)

使用说明教程-生活视频-搜狐视频

光速虚拟机下载地址链接：123云盘

随风助手下载链接：123云盘

王者最低上榜战力查询

王者战力免费查询 - Smwan.cn

战区修改的要求：

1.防沉迷登录不上游戏的，改不了

2.信誉分低于90分没法参与排位赛的，改不了

3.禁止上榜封榜的，改不了

4.当前日期不是周一的，改不了

5.修改战区时间为：每周一早9:00-23:59

6.每周一只能改一次，自己修改过的，改不了

namespace bit
{
  template<class T>
  class vector
  {
  public:
    // Vector的迭代器是一个原生指针
 
    typedef T* iterator；
 
    typedef const T* const_iterator；
 
    iterator begin()
    {
      return _start;
    }
    iterator end()
    {
      return _finish;
    }
    const_iterator cbegin()const
    {
      return _start;
    }
    const_iterator cend() const
    {
      return _finish;
    }
 
 
    // construct and destroy
    vector(): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
    {}
    vector(int n, const T& value = T())
      : _start(nullptr), _finish(nullptr),_endOfStorage(nullptr)
    {
      reserve(n);
      while (n--)
      {
        push_back(value);
      }
    }
 
    template<class InputIterator>
 
    vector(InputIterator first, InputIterator last)
    {
      reserve(last - first);
      while (first != last)
      {
        push_back(*first);
        ++first;
      }
    }
 
    vector(const vector<T>& v)
      : _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
    {
      reserve(v.capacity());
      iterator it = begin();
      const_iterator vit = v.cbegin();
      while (vit != v.cend())
      {
       *it++ = *vit++;
      }
      _finish = _start + v.size();
      _endOfStorage = _start + v.capacity();
    }
 
    vector<T>& operator= (vector<T> v)
    {
      swap(v);
      return *this;
    }
 
    ~vector()
    {
      delete[] _start;
      _start = _finish = _endOfStorage = nullptr;
    }
 
 
    // capacity
    size_t size() const 
    {
      return _finish - _start;
    }
 
    size_t capacity() const
    {
      return _endOfStorage - _start;
    }
 
    void reserve(size_t n)
    {
 
      if (n > capacity())
      {
        size_t oldSize = size();
        T* tmp = new T[n];
        if (_start)
        {
          for (size_t i = 0; i < oldSize; ++i)
          tmp[i] = _start[i];
        }
        _start = tmp;
        _finish = _start + size;
        _endOfStorage = _start + n;
      }
 
    }
 
    void resize(size_t n, const T& value = T())
    {
      // 1.如果n小于当前的size，则数据个数缩小到n
      if (n <= size())
      {
        _finish = _start + n;
        return;
      }
 
      // 2.空间不够则增容
      if (n > capacity())
       reserve(n);
 
      // 3.将size扩大到n
      iterator it = _finish;
      iterator _finish = _start + n;
      while (it != _finish)
      {
        *it = value;
        ++it;
      }
    }
 
    ///access///
 
    T& operator[](size_t pos)
    {
      return _start[pos];
    }
 
    const T& operator[](size_t pos)const
    {
      return _start[pos];
    }
 
 
    ///modify/
 
    void push_back(const T& x)
    {
      insert(end(), x);
    }
 
    void pop_back()
    {
      erase(--end());
    }
 
    void swap(vector<T>& v)
    {
      swap(_start, v._start);
      swap(_finish, v._finish);
      swap(_endOfStorage, v._endOfStorage);
    }
 
    iterator insert(iterator pos, const T& x)
    {
      assert(pos <= _finish);
 
      // 空间不够先进行增容
      if (_finish == _endOfStorage)
      {
        size_t size = size();
        size_t newCapacity = (0 == capacity())? 1 : capacity() * 2;
        reserve(newCapacity);
 
        // 如果发生了增容，需要重置pos
        pos = _start + size;
      }
 
      iterator end = _finish - 1;
      while (end >= pos)
      {
        *(end + 1) = *end;
        --end;
      }
      *pos = x;
      ++_finish;
      return pos;
    }
 
 
    // 返回删除数据的下一个数据
 
// 方便解决:一边遍历一边删除的迭代器失效问题
 
    iterator erase(Iterator pos)
    {
      // 挪动数据进行删除
      iterator begin = pos + 1;
      while (begin != _finish) 
      {
        *(begin - 1) = *begin;
        ++begin;
      }
      --_finish;
      return pos;
    }
  private:
    iterator _start; // 指向数据块的开始
    iterator _finish; // 指向有效数据的尾
    iterator _endOfStorage; // 指向存储容量的尾
 
  };
 
}