0
0

STL容器入门基础Ⅰvector

STL是C++标准库的重要组成部分，vector容器在实际中非常的重要，它常见的接口使用我们都要熟悉，这一篇肝一波vector容器常见的接口使用，帮助大家深入理解

vector容器的接口使用

vector容器的初始化

  1. //构造函数初始化
  2. void test_vector1()
  3. {
  4.   //存储int
  5.   vector<int>v1;
  6.   v1.push_back(1);
  7.   v1.push_back(2);
  8.  
  9.   //存储double
  10.   vector<double>v2;
  11.   v2.push_back(1.1);
  12.   v2.push_back(2.2);
  14.   //存储string
  15.   vector<string>v3;
  16.   v3.push_back("李白");//
  17.   v3.push_back("杜甫");
  18.   v3.push_back("苏轼");
  19.   //用10个5初始化 
  20.   vector<int>v4(10,5);
  21. }

vector容器的遍历方法

  1. //vector容器的遍历
  2. void test_vector2()
  3. {
  4.   vector<int>v1;
  5.   v1.push_back(1);
  6.   v1.push_back(2);
  7.   v1.push_back(3);
  8.   v1.push_back(4);
  9.   //1.下标+[]
  10.   for (size_t i = 0; i < v1.size(); ++i)
  11.   {
  12.    cout << v1[i] << " ";//打印1 2 3 4
  13.   }
  14.   cout << endl;
  15.   //2.迭代器
  16.   vector<int>::iterator it = v1.begin();
  17.   while (it != v1.end())
  18.   {
  19.    cout << *it <<" ";//打印1 2 3 4
  20.    ++it;
  21.   }
  22.   cout << endl;
  23.   //3.范围for
  24.   for (auto e : v1)
  25.   {
  26.    cout << e << " ";//打印1 2 3 4
  27.   }
  28.   cout << endl;
  29. }

vector容器的空间增长问题

  1. //测试增容 vs下
  2. void test_vector3()
  3. {
  4.   size_t sz;
  5.   vector<int> v;
  6.   v.reserve(100);//提前开辟空间 可以减少扩容
  7.   sz = v.capacity();//初始容量 
  8.   cout << "making v grow:\n";
  9.   for (int i = 0; i < 100; ++i)
  10.   {
  11.    v.push_back(i);
  12.    if (sz != v.capacity())
  13.    {
  14.     sz = v.capacity();
  15.     cout << "capacity changed: " << sz << '\n';//扩容1.5倍
  16.    }
  17.   }
  18.   //vector<int> v1;
  19.   //v1.resize(100, 1);// resize扩容同时初始化
  20.   v.resize(10);
  21.   cout << v.size() << endl;//打印10  resize扩容 不会缩容
  22.   cout << v.capacity()<<endl;//打印100 
  23. }

vector容器指定位置插入删除

  1. //指定位置插入 删除  
  2. //使用迭代器 不支持下标
  3. void test_vector4()
  4. {
  5.   vector<int>v1;
  6.   v1.push_back(1);
  7.   v1.push_back(2);
  8.   v1.push_back(3);
  9.   v1.push_back(4);
  10.   //头插1个0
  11.   v1.insert(v1.begin(), 0);
  12.   for (auto e : v1)
  13.   {
  14.     cout << e << " ";//打印0 1 2 3 4
  15.   }
  16.   cout << endl;
  18.   //第三个位置插入2
  19.   v1.insert(v1.begin() + 3, 2);
  20.   for (auto e : v1)
  21.   {
  22.     cout << e << " ";//打印0 1 2 2 3 4
  23.   }
  24.   cout << endl;
  26.   //头删三次
  27.   v1.erase(v1.begin());
  28.   v1.erase(v1.begin());
  29.   v1.erase(v1.begin());
  30.   for (auto e : v1)
  31.   {
  32.     cout << e << " ";//打印2 3 4
  33.   }
  34.   cout << endl;
  35. }

vector容器的查找

  1. //要复用find查找函数 
  2. void test_vector5()
  3. {
  4.   vector<int>v1;
  5.   v1.push_back(1);
  6.   v1.push_back(2);
  7.   v1.push_back(3);
  8.   v1.push_back(4);
  9.   //查找3删除
  10.   auto pos=find(v1.begin(), v1.end(), 3);
  11.   if (pos != v1.end())
  12.   {
  13.    cout << "找到了" << endl;
  14.    v1.erase(pos);//删除3
  15.   }
  16.   else
  17.   {
  18.    cout << "没有找到" << endl;
  19.   }
  20.   //遍历
  21.   for (auto e : v1)
  22.   {
  23.    cout << e << " ";
  24.   }
  25.   cout << endl;
  26. }

vector容器数据的排序

  1. //调用sort排序
  2. //随机访问迭代器 
  3. void test_vector6()
  4. {
  5.   vector<int>v1;
  6.   v1.push_back(1);
  7.   v1.push_back(3);
  8.   v1.push_back(9);
  9.   v1.push_back(7);
  10.   v1.push_back(10);
  11.   sort(v1.begin(), v1.end());//默认升序 
  12.   //sort(v1.begin(), v1.end(),greater<int>());//使用仿函数排降序
  13.   for (auto e : v1)
  14.   {
  15.    cout << e << " ";//1 3 7 9 10
  16.   }
  17.   cout << endl;
  18. }

vector容器的模拟实现

模拟实现vector容器可以帮助我们更好的理解底层是如何实现的

模拟实现函数的接口

  1. template<class T>
  2. class vector
  3. {
  4. public:
  6.     typedef T* iterator;
  7.     typedef const T* const_iterator;
  9.     //无参的构造
  10.     vector()
  11.         :_start(nullptr)
  12.         , _finish(nullptr)
  13.         , _endofstorage(nullptr)
  14.     {}
  16.     //带参构造 现代写法 迭代器区间 
  17.     template <class InputIterator>
  18.     vector(InputIterator first, InputIterator last)
  19.         :_start(nullptr)
  20.         , _finish(nullptr)
  21.         , _endofstorage(nullptr)
  22.     {
  23.         while (first != last)
  24.         {
  25.             push_back(*first);
  26.             ++first;
  27.         }
  28.     }
  29.     //交换函数
  30.     void swap(vector<T>& v)
  31.     {
  32.         std::swap(_start, v._start);
  33.         std::swap(_finish, v._finish);
  34.         std::swap(_endofstorage, v._endofstorage);
  35.     }
  36.     //拷贝构造现代写法 复用带参构造
  37.     vector(const vector<T>& v)
  38.         :_start(nullptr)
  39.         , _finish(nullptr)
  40.         , _endofstorage(nullptr)
  41.     {
  42.         vector<T> tmp(v.begin(), v.end());
  43.         this->swap(tmp);
  44.         cout << "调用拷贝构造" << endl;
  45.     }
  46.     //赋值
  47.     vector<T>& operator=(vector<T> v)
  48.     {
  49.         cout << "调用赋值" << endl;
  50.         this->swap(v);
  51.         return *this;
  52.     }
  53.     //析构
  54.     ~vector()
  55.     {
  56.         if (_start)
  57.         {
  58.             delete[]_start;
  59.             _start = _finish = _endofstorage = nullptr;
  61.         }
  62.     }
  64.     //大小
  65.     size_t size()const
  66.     {
  67.         return _finish - _start;
  68.     }
  69.     //容量
  70.     size_t capacity()const
  71.     {
  72.         return _endofstorage - _start;
  73.     }
  75.     //迭代器
  76.     iterator begin()
  77.     {
  78.         return _start;
  79.     }
  81.     const_iterator begin()const
  82.     {
  83.         return _start;
  84.     }
  86.     iterator end()
  87.     {
  88.         return _finish;
  89.     }
  91.     const_iterator end()const
  92.     {
  93.         return _finish;
  94.     }
  96.     //扩容函数
  97.     void reserve(size_t n)
  98.     {
  99.         size_t sz = size();
  100.         if (n > capacity())
  101.         {
  102.             T* tmp = new T[n];//先开辟新空间
  103.             if (_start)//有空间才拷贝
  104.             {
  105.                 //memcpy(tmp, _start, size() * sizeof(T));//拷贝数据
  106.                 for (size_t i = 0; i < size(); ++i)
  107.                 {
  108.                     tmp[i] = _start[i];
  109.                 }
  110.                 delete[]_start;//释放旧空间
  111.             }
  112.             _start = tmp;//在指向新空间
  113.         }
  114.         //同时让finish和capacity都指向新空间
  115.         _finish = _start + sz;
  116.         _endofstorage = _start + n;
  117.     }
  118.     //扩容加初始化 注意分情况
  119.     void resize(size_t n, const T& val = T())
  120.     {
  121.         if (n > capacity())
  122.         {
  123.             reserve(n);
  124.         }
  125.         if (n > size())
  126.         {
  127.             while (_finish < _start + n)
  128.             {
  129.                 *_finish = val;
  130.                 ++_finish;
  131.             }
  132.         }
  133.         else
  134.         {
  135.             _finish = _start + n;
  136.         }
  137.     }
  139.     //尾部插入数据
  140.     void push_back(const T& x)
  141.     {
  142.         if (_finish == _endofstorage)
  143.         {
  144.             size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  145.             reserve(newcapacity);
  146.         }
  147.         *_finish = x;//插入到finish位置
  148.         ++_finish;//更新大小
  149.     }
  150.     //尾删数据
  151.     void pop_back()
  152.     {
  153.         if (_finish > _start)
  154.         {
  155.             --_finish;
  156.         }
  157.     }
  158.     //返回数据
  159.     T& operator[](size_t pos)
  160.     {
  161.         assert(pos < size());
  162.         return _start[pos];
  163.     }
  164.     const T& operator[](size_t pos)const
  165.     {
  166.         assert(pos < size());
  167.         return _start[pos];
  168.     }
  170.     //pos位置插入x
  171.     iterator insert(iterator pos, const T& x)
  172.     {
  173.         assert(pos >= _start && pos <= _finish);
  174.         //先扩容
  175.         if (_finish == _endofstorage)
  176.         {
  177.             size_t n = pos - _start;//扩容后pos失效，要更新
  178.             size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  179.             reserve(newcapacity);
  180.             pos = _start + n;
  181.         }
  182.         //挪动数据
  183.         iterator end = _finish - 1;
  184.         while (end >= pos)
  185.         {
  186.             *(end + 1) = *end;
  187.             --end;
  188.         }
  189.         *pos = x;
  190.         ++_finish;
  192.         return pos;
  193.     }
  194.     //erase 
  195.     iterator erase(iterator pos)
  196.     {
  197.         assert(pos >= _start && pos < _finish);
  198.         iterator it = pos + 1;
  199.         while (it != _finish)
  200.         {
  201.             *(it - 1) = *it;
  202.             ++it;//...
  203.         }
  204.         --_finish;
  205.         return pos;//指向最后被删除元素的后一个位置
  206.     }
  208.     void clear()
  209.     {
  210.         _finish = _start;
  211.     }
  212. private:
  213.     iterator _start;
  214.     iterator _finish;
  215.     iterator _endofstorage;
  216. };

模拟实现的测试

测试要和上面模拟接口放到一个命名空间里面

  1. //尾插 尾删测试
  2. void Test_vector1()
  3. {
  4.   vector<int>v;
  5.   v.push_back(1);
  6.   v.push_back(2);
  7.   v.push_back(3);
  8.   v.push_back(4);
  9.   v.push_back(5);
  11.   v.insert(v.begin(), 0);//头部插入0
  13.   v.pop_back();//删除两个
  14.   v.pop_back();
  15.   vector<int>::iterator it = v.begin();
  16.   while (it != v.end())
  17.   {
  18.    cout << *it << " ";//打印0 1 2 3
  19.    ++it;
  20.   }
  21.   cout << endl;
  22.   }
  24. //指定位置插入测试
  25. void Test_vector2()
  26. {
  27.   vector<int>v;
  28.   v.push_back(1);
  29.   v.push_back(2);
  30.   v.push_back(3);
  31.   v.push_back(4);
  32.   //指定位置偶数前插入20
  33.   vector<int>::iterator it = v.begin();
  34.   while (it != v.end())
  35.   {
  36.    if (*it % 2 == 0)
  37.    {
  38.     //要考虑迭代器失效
  39.     it = v.insert(it, 20);
  40.     ++it;
  41.    }
  42.     ++it;
  43.   }
  44.   for (auto e : v)
  45.   {
  46.    cout << e << " ";
  47.   }
  48.   cout << endl;
  49. }
  51. //指定位置删除 
  52. void Test_vector3()
  53. {
  54.   vector<int>v;
  55.   v.push_back(1);
  56.   v.push_back(2);
  57.   v.push_back(3);
  58.   v.push_back(4);
  59.   v.push_back(5);
  60.   v.push_back(2);
  61.   //删除偶数
  62.   vector<int>::iterator it = v.begin();
  63.   while (it != v.end())
  64.   {
  65.     if (*it % 2 == 0)
  66.     {
  67.      it = v.erase(it);
  68.     }
  69.     else
  70.     {
  71.      ++it;
  72.     }
  73.   }
  75.   for (auto e : v)
  76.   {
  77.    cout << e << " ";//打印1 3 5
  78.   }
  79.   cout << endl;
  80. }
  82. //迭代器区间初始化
  83. void Test_vector4()
  84. {
  85.   vector<int>v;
  86.   v.push_back(1);
  87.   v.push_back(2);
  88.   v.push_back(3);
  89.   v.push_back(4);
  90.   //迭代器模板
  91.   vector<int>v1(v.begin(), v.end());
  93.   std::string s("hello");
  94.   vector<char>v2(s.begin(), s.end());
  96.   for (auto e : v1)
  97.   {
  98.     cout << e << " ";//打印1 2 3 4
  99.   }
  100.   cout << endl;
  102.   for (auto e : v2)
  103.   {
  104.     cout << e << "";//打印 hello
  105.   }
  106.   cout << endl;
  108. }
  110. //拷贝构造和赋值测试
  111. void Test_vector5()
  112. {
  113.   vector<int>v;
  114.   v.push_back(1);
  115.   v.push_back(2);
  116.   v.push_back(3);
  117.   v.push_back(4);
  118.   //迭代器区间
  119.   vector<int>v1(v.begin(), v.end());
  120.   for (auto e : v1)
  121.   {
  122.    cout << e << " ";
  123.   }
  124.   cout << endl;
  126.   vector<int>v3(v);//调用构造 
  128.   for (auto e : v3)
  129.   {
  130.    cout << e << " ";
  131.   }
  132.   cout << endl;
  133. }

学习vector一定要学会查看文档，这里放一个官方文档链接vector容器文档，vector在实际中非常的重要，我们只要熟悉常见的接口就可以

希望这篇文章大家有所收获，我们下篇见

标签： c++ 开发语言 大数据
本文转载自: https://blog.csdn.net/qq_72486849/article/details/125947593
版权归原作者 小圣编程 所有， 如有侵权，请联系我们删除。
登录后发布评论

“STL容器入门基础Ⅰvector”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？