vector类实现

c无序

已于 2024-05-26 14:22:59 修改

阅读量327

点赞数 4

分类专栏： C++ 文章标签： c++

于 2024-05-22 21:14:47 首次发布

本文链接：https://blog.csdn.net/2202_75331338/article/details/139129772

版权

C++ 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

vector类operator[]()重载函数

vector类获取容量大小函数

vector类begin() end()函数

vector类构造函数

//默认构造函数
 Vector():
 _start(nullptr),
 _finish(nullptr),
  _end_of_storage(nullptr)
  {
      
  }

也可以这样

Vector() = default;

vector类根据个数构造函数

//缺省值不能给0；T声int可以给0，T如果是其它类型呢？给不了0
Vector(size_t n , const T& value = T()){//匿名对象
     for (size_t i = 0; i < n; i++) {
         push_back(value);
     }
  }

C++内置类型也支持构造，C语言不行

例如初始化int可以这样写

// C++内置类型进行了升级，也有构造 
		int i = 0;
		int j(1);
		int k = int();
		int x = int(2);

vector类根据迭代器区间构造函数

vector类的迭代器区间不局限于本类的迭代器，所以需要用到函数模版

 template<class InputIterator>
    Vector(InputIterator first,InputIterator last)
    {
        while (first != last) {
            push_back(*first);
            first++;
        }
    }

vector类拷贝构造函数

    //拷贝构造
    //v2(v1)
    Vector(Vector<T>& v1){
        reserve(v1.capacity());
        for (auto e : v1) {
            push_back(e);
        }
    }

vector类析构函数

 ~Vector()
 {
      if (_start)
      {
        delete[] _start;
         _start = _finish = _end_of_storage = nullptr;
   }
 }

vector类赋值运算符重载函数

    //赋值运算符重载
    //v1 = v2
    Vector<T>& operator=(Vector<T> v){
        swap(v);
        return *this;
    }

vector类operator[]()重载函数

    const T& operator[](size_t i)const
    {
        assert(i < size());
        return _start[i];
    }

vector类获取容量大小函数

size_t capacity(){
    return _end_of_storage - _start;
}

vector类begin() end()函数

    iterator begin(){
        return _start;
    }
    
    iterator end(){
        return _finish;
    }
    
    const_iterator begin()const{
        return _start;
    }
    
    const_iterator end()const{
        return _finish;
    }

vector类reserve()函数

 void reserve(size_t n){
     //如果新空间大于原空间才扩容
     if (n > capacity()) {
          //记录旧空间size个数   目的：正确指引新空间_finish位置
          size_t oldsize = size();
          //开辟新空间
          T* tmp = new T[n];
          //如果有数据时进行数据移动
          if (_start){
              memcpy(tmp, _start, sizeof(T) * size());
            delete[] _start;
           }
           //改变_start _finish _end_of_storage新指向
        _start = tmp;
        _finish = _start + oldsize;
        _end_of_storage = _start + n;
            
      }
 }

vector类push_back()函数

void push_back(T x)
//只要是进行插入操作都需要考虑是否扩容
{
    if (_finish == _end_of_storage) {
    size_t newcapacity = capacity() == 0? 4 :2 * capacity();
     reserve(newcapacity);
  }
  *_finish = x;
   _finish++;
        
//      insert(end(), x);
 }

vector类pop_back()函数

    void pop_back(){
        //空间有数据才删除
        assert(size() > 0);
        _finish--;
    }

vector类insert()函数

iterator insert(iterator pos, const T& x
//pos位置要合理
 assert(pos >= _start);
 assert(pos <= _finish);
//判断是否需要扩容
    if (_finish == _end_of_storage) {
     size_t len = pos - _start;
     size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
     reserve(newcapacity);
       //空间开辟好了 _start _finish _end_of_stotage 指向新空间
       //pos也需要指向新空间
     pos = _start + len;
   }
      iterator end = _finish;
      while (end > pos ) {
       *(end) = *(end -1);
       end--;
 }
       *pos = x;
       ++_finish;
       return pos;
     
    }

vector类erase()函数

void erase(iterator pos){
    assert(pos <= _finish);
    assert(pos >= _start);
    iterator it = pos + 1;
    while (it < _finish) {
        *(it - 1) = *it;
        it++;
    }
    _finish--;

}

vector类swap()函数

    //swap()函数
    void swap(Vector<T> v)
    {
        std::swap(_start, v._start);
        std::swap(_finish, v._finish);
        std::swap(_end_of_storage, v._end_of_storage);
    }

2.2 vector迭代器失效（重点）

vector 迭代器失效问题。(重点) 迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如:vector 的迭代器就是原生态指针 T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

对于vector可能会导致其迭代器失效的操作有：

1.会引起其底层空间改变的操作，都有可能是迭代器失效。

insert引起的迭代器失效

指定位置元素删除操作-erase引起的迭代器失效

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了

比如删除vector中所有的偶数

例题：下列结果中输出什么

#include <iostream>
#include <vector>
using namespace std;
int main(void)
{
    vector<int>array;
    array.push_back(100);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(500);
    vector<int>::iterator itor;
    for(itor=array.begin();itor!=array.end();itor++)
    {
        if(* itor==300)
        {
            itor=array.erase(itor);
        }
    }
    for(itor=array.begin();itor!=array.end();itor++)
    {
            cout<<*itor<<" ";
    }
  return 0;
}


//100 300 300 500