C++ vector深究

最新推荐文章于 2023-11-14 16:27:25 发布
最新推荐文章于 2023-11-14 16:27:25 发布
阅读量313 收藏
点赞数
分类专栏： C/C++ 文章标签： vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31930499/article/details/79801247
版权

一  size和capacity区别

size的大小是指的容器所含的元素个数。STL容器都含有该方法，取得容器的元素个数。

capacity的大小是指容器所分配的内存大小。vector特有的方法。（因为别的容器大小和容量相等，所以没必要提供capacity）

关系：capacity >= size

二 resize和reserve

（1）resize 重新分配元素多少  --> 改变size大小也可以改变capacity大小

       resize可以减少容器的容量

（2）reserve 预留一定的空间（分配容器内存，必须是大于等于原来的内存空间，不然无效） -->改变capacity大小

      1.如果预留空间大于当前容量（），则分配新的存储空间，否则该方法不起作用。

   2.reserve（）不能用于减少容器的容量，为此提供了shrink_to_fit() 

假设

vector<int> sample;

当前size()为50, capacity()为100,经过以下操作:

(1) resize(10).  //size() == 10; 10到49下标的元素被删除. capacity()==100,不变,没有进行内存重新分配.

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.resize(10);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:10

capacity:100

 

(2) resize(60).  //size() == 60; 50到59下标用默认构造函数填充. capacity() == 100,不变,没有进行内存重新分配.

 

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.resize(60);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:60

capacity:100

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

 

 

(3) resize(60, 9999).  //size() == 60; 50到59下标用9999填充. capacity() == 100,不变,没有进行内存重新分配.

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.resize(60,999);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    for(int i = 0;i < v.capacity();i++)
        cout << v[i] << " ";
    cout << endl;

size:50

capacity:100

size:60

capacity:100

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 999 999 999 999 999 999 999 999 999 999 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

 

(4) resize(200). //size() == 200; 50到199下载用默认构造函数填充. capacity() == 200, 自动扩容,重新分配内存.

 

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.resize(200);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:200

capacity:200

 

 (5) reserve(10). //size() == 50; 不变,没有元素被删除, capacity() == 100, 不变. 即reserve调用没起作用.

 

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.reserve(10);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:50

capacity:100

 

(6) reserve(60). //size() == 50; 元素没有变, capacity() == 100, 不变. 即reserve调用没起作用.

 

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.reserve(60);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:50

capacity:100

 

(7) reserve(200). //size() == 50; 元素没有变, capacity() == 200, 扩容,重新分配内存.

 

    vector<int> v(50);
    v.reserve(100);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    v.reserve(200);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;

size:50

capacity:100

size:50

capacity:200

 

三 push_back()  insert()原理

 

      push_back在容器的尾部增加元素，这里的尾部是指最后一个元素的后面（这个很重要，区别size和capacity的关键）vector在push_back的时候，如果空间不足，会自动增补一些空间，如果没有预留的空间可用，就直接申请另一块可用的连续的空间，把数据拷贝过去，然后删除旧空间，使用新空间，结果造成效率低下。

  insert在指定位置处的元素前插入一个新的元素。直接使容器的大小（Size）增加，增加的值就是所插入元素的个数。当且仅当新的容器的大小超过当前容器的容量（Capacity），才会导致一次已分配的存储空间的自动重分配。因为向量用数组作为它的内部存储结构，将元素插入除了末尾的其它位置会导致容器迁移该位置后的所有元素到新的位置。相比其它类型的顺序容器（如 std::list 或 std::forward_list C++11），该操作是极其耗性能的，这样子看来，insert比push_back效率低。

     push_back和insert当前空间不足的情况下，会自动增补一些空间，如果没有预留的空间可用，就直接申请另一块可用的连续的空间，把数据拷贝过去，然后删除旧空间，使用新空间，其新的空间大小是旧的2倍（不同编译器倍数不一样）

  如果在事先预见到有较大空间需求，就可以先用reserve预留一定的空间，避免内存重复分配和大量的数据搬移，提高了效率 。

void fun3()
{
    vector<int> myVec(3);
    cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    myVec.push_back(1);
    cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
}

运行结果：

size:3 capacity:3

size:4 capacity:6

测试vector每次增长分配的内存是几倍  --> 当超过当前容器的容量，将以2的倍数增长(本环境mac g++编译器，不同环境和编译器结果不同)

 

四  容器初始化

 

（1）vector<int> v(10);

定义一个容器v，容器的size = 10，capacity = 10

（2）vector<int> v;

       v.reserve(10);

定义一个容器v，容器的size = 0，capacity = 10  ==> 该容器容器内存大小10，但是目前容纳的元素个数为0，可以通过push_back来增加元素。

    vector<int> e;
    e.reserve(10);
    cout << "size:" << e.size() << endl;
    cout << "capacity:" << e.capacity() << endl;
    for(int i = 0; i < 10; i++)
    {
        e.push_back(i);
        cout << e[i] << " "; //输出正常0-9
    }
    cout << endl;
    cout << "size:" << e.size() << endl;
    cout << "capacity:" << e.capacity() << endl;

运行结果：

size:0

capacity:10

0 1 2 3 4 5 6 7 8 9 

size:10

capacity:10

由结果可以看出，因为容器e没有元素，所以push_back是从第一个开始增加。

 

（3）

    vector<int> v(10);  

    v.reserve(20); 

定义了一个容器v，容器的size = 10，capacity = 20 ==> 该容器容器内存大小20，但是目前容纳的元素个数为10，可以通过push_back来增加元素。

    vector<int> c(10);
    c.reserve(20);
    cout << "size:" << c.size() << endl;
    cout << "capacity:" << c.capacity() << endl;
    for(int i = 0; i < 10; i++)
    {
        c.push_back(i);
    }
    for(int i = 0; i < c.size(); i++)
    {
        cout << c[i] << " ";
    }
    cout << endl;
    cout << "size:" << c.size() << endl;
    cout << "capacity:" << c.capacity() << endl;

运行结果：

size:10

capacity:20

0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 

size:20

capacity:20

由结果可以看出，因为容器c含有10个元素，所以push_back是从第11个开始增加。

 

（4）

void fun5()
{
    vector<int> c(10);  //这个10代表容器的元素个数大小
    c.reserve(20);      //这个20代表容器的容量大小 所以后面push_back是从
    cout << "size:" << c.size() << endl;
    cout << "capacity:" << c.capacity() << endl;

    c[5] = 5;
    
    c[10] = 10;
    c[15] = 15;
    
    c[20] = 20;
    for(int i = 0;i < c.capacity();i++)
        cout << c[i] << " ";
    cout << endl;
    
    c.push_back(1);
    c.push_back(1);
    c.push_back(1);
    c.push_back(1);
    c.push_back(1);
    c.push_back(1);
    c.push_back(1);
    for(int i = 0;i < c.capacity();i++)
        cout << c[i] << " ";
    cout << endl;
}

运行结果：

size:10

capacity:20

0 0 0 0 0 5 0 0 0 0 10 0 0 0 0 15 0 0 0 0 

0 0 0 0 0 5 0 0 0 0 1 1 1 1 1 1 1 0 0 0 

 

五

 我们都知道, vector是在内存中是连续分布的,所以设计上总会在所有已经有元素外预留一些空间,否则每次追加新元素时都要再次分配内存,那准备就绪将很低.

假如当vector中可能会存在约10个元素时, 比较两种做法:

1. vector<int> myVec, 然后10次调用 myVec.push_back(****)

2. vector<int> myVec(10), 然后10次调用 myVec.push_back(****)

void fun1()
{
    vector<int> myVec;
    cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    for(int i = 0;i < 10;i++){
        myVec.push_back(i);
        cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    }
}

void fun2()
{
    vector<int> myVec(10);
    cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    for(int i = 0;i < 10;i++){
        myVec.push_back(i);
        cout << "size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    }
}
int main()
{
    fun1();
    cout << endl;
    fun2();
}

运行结果：

size:0 capacity:0

size:1 capacity:1     1次

size:2 capacity:2     2次

size:3 capacity:4     3次

size:4 capacity:4

size:5 capacity:8     4次

size:6 capacity:8

size:7 capacity:8

size:8 capacity:8

size:9 capacity:16    5次

size:10 capacity:16

 

size:10 capacity:10  1次

size:11 capacity:20  2次

size:12 capacity:20

size:13 capacity:20

size:14 capacity:20

size:15 capacity:20

size:16 capacity:20

size:17 capacity:20

size:18 capacity:20

size:19 capacity:20

size:20 capacity:20

由结果看：做法2只需要进行2次内存分配,而做法1进行5次内存分配了.

可以使用下面的方法：

void fun3()
{
    vector<int> myVec;
    vector<int> yourVec;
    yourVec.reserve(10);
    cout << "size:" << yourVec.size() << " capacity:" << yourVec.capacity() << endl;
    for(int i = 0;i < 10;i++){
        yourVec.push_back(i);
        cout << "size:" << yourVec.size() << " capacity:" << yourVec.capacity() << endl;
    }
    cout << endl <<"size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    myVec = yourVec;
    cout  <<"size:" << myVec.size() << " capacity:" << myVec.capacity() << endl;
    for(int i = 0;i < 10;i++)
        cout << myVec[i] << " ";
    cout << endl;
}

size:0 capacity:10

size:1 capacity:10

size:2 capacity:10

size:3 capacity:10

size:4 capacity:10

size:5 capacity:10

size:6 capacity:10

size:7 capacity:10

size:8 capacity:10

size:9 capacity:10

size:10 capacity:10

 

size:0 capacity:0

size:10 capacity:10  1次

0 1 2 3 4 5 6 7 8 9 

由上面可知，内存只扩容了一次。

六 二维容器

#include <iostream>
#include <vector>

using namespace std;

static vector<vector<int> > v(5);

void fun1(int n)
{
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    for(int i = 0;i < v.size();i++){
        v[i].reserve(100);
        cout << "size:" << v[i].size() << endl;
        cout << "capacity:" << v[i].capacity() << endl;
    }
    cout << "************1***********" << endl;

    //清除 二维容器的第二维
    for(int i = 0;i < v.size();i++){
        v[i].clear();
        cout << "size:" << v[i].size() << endl;
        cout << "capacity:" << v[i].capacity() << endl;
    }
    //清除 二维容器的第一维
    //v.clear();

    
    cout << "************2***********" << endl;
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    
    for(int i = 0;i < v.size();i++){
        for(int j = 0;j < v[i].capacity();j++){
            v[i].push_back(n);
        }
    }
    cout << "************3***********" << endl;
    for(int i = 0;i < v.size();i++){
        cout << "size:" << v[i].size() << endl;
        cout << "capacity:" << v[i].capacity() << endl;
    }
    cout << "************4***********" << endl;
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    
    for(int i = 0;i < v.size();i++){
        for(int j = 0;j < v[i].capacity();j++){
            cout << v[i][j] << " ";
        }
        cout << endl;
    }

}

int main()
{
    fun1(1);
}

 

C++重构vector
06-28
c++ 重构vector以重构：clear()push_back()emplace_back()pop_back()resize()front()back()size()empty()insert()的多种调用方法assign()的多种调用方法=（赋值为一个普通的数组）[]begin()end()rbegin()rend()
size与capacity的区别
jyx1572676601的博客
02-05 2426
先放代码： 下面讨论size与capacity的区别： size一定与动态数组aha声明时的大小(即1000)相等，它是我们显式预定的空间。 而capacity则是系统数组在内存中连续空间的总大小，也就是说，我们可能申请了100大小的内存，但系统开辟空间时，给我们开辟了200大小的连续内存，这多出来的100，可以理解为备用空间。我们自己使用时，只能使用size大小内的空间(除非在尾部先添加)，而不能直接使用备用空间（如下标越界）。 一般而言，size=capacity ，此时没有备用空间。如果
vector容器中size与capacity的区别
new9232的博客
11-20 5051
理解这两个方法的区别之前，需要先搞清楚vector的原理。vector底层是一个动态数组，插入元素时会申请新的空间，但考虑到效率问题，并不是每插入一个元素，就申请一个空间，而是事先先申请好一段空间，开始插入元素，当空间不足时，再重新申请一块更大的空间。并将原来空间中的数组拷贝到新空间中，再继续插入元素。 而size就是vector中元素的个数，而capacity就是vector申请的内存空间的大小。 std::vector<int> v1; for (i...
vector的容量（capacity）和大小（size）的区别
qq_43768296的博客
05-30 7376
1.概念 容器的capacity：当前分配的存储容量，其实也就是当前情况下能够存储的元素个数 容器的size:表示容器中所包含（已经存储）元素的个数； 我们可以通过该模板类提供的成员函数，capacity（）来获得当前容器的容量，以及size（）来获得当前容器的大小 2.capacity 和size的关系 在不分配空间的前提下，vectoe.size()<=vector.capacity(),一旦元素个数超过了当点分配空间容许的元素个数，容器就会扩容。 3.验证 #include<iostr
C++ vector容器注意事项
TABE_的博客
12-28 3081
这里写目录标题容量（capacity）和大小（size）的区别容器扩容的本质emplace_back()和push_back()的区别emplace()和insert()的区别 容量（capacity）和大小（size）的区别 vector 容器的容量（用 capacity 表示），指的是在不分配更多内存的情况下，容器可以保存的最多元素个数；而 vector 容器的大小（用 size 表示），指的是它实际所包含的元素个数。 对于一个 vector 对象来说，通过该模板类提供的 capacity() 成员函数
【C++】STL——vector的有关空间的函数介绍和使用、size和capacity函数、resize和reserve函数
Crocodile1006的博客
07-17 2808
SLT、vector的使用、vector空间增长问题、size（获取数据个数）capacity （获取容量大小）empty （判断是否为空）resize （改变vector的size）reserve （改变vector的capacity）
C++ vector笔记
02-22
### C++ Vector 使用详解 #### 一、Vector 概述 `std::vector` 是 C++ 标准库中提供的一种动态数组容器。它能够自动调整大小以适应数据的增加或减少，使得开发者无需手动管理内存。这为编程带来了极大的便利。 **...
C++ Vector 容器详细说明.pdf
05-11
### C++ Vector 容器详解 #### 一、概述 `vector`是C++标准模板库（STL）中的一种动态数组容器。相比于传统的C语言风格的数组，`vector`提供了一种更加灵活且安全的方式来处理动态数据集合。`vector`能够自动管理...
c++vector课堂笔记
最新发布
08-25
c++vector课堂笔记
C++ Vector用法深入剖析
09-04
C++ Vector是标准模板库(STL)中的一个重要组件，它是一种动态数组，可以在运行时自动调整大小。在本文中，我们将深入探讨C++ Vector的多种用法，帮助开发者更好地理解和运用这一工具。 首先，创建一个Vector的基本...
vector的size和capacity有什么区别？怎么使capacity值为0？
热门推荐
pengshengli的博客
01-11 1万+
要说清这个问题，先抛出另外一个问题：vector和普通的数组有什么区别？ 你可能会说：大家都知道，vector是动态数组~~ 没错！ 但是怎么个动态法？怎么实现的？ 好，先说一下普通数组，比如：int arr[10]或者int *arr= new int[10]; 其实是你到内存里占了10个int大小的地方（空间）； 当然，你可以这样操作：int a = arr[100];arr...
capacity size
混沌的博客
06-15 543
int cnt = vDetailInfo->sGame.seqCondition.size(); //int cnt = vDetailInfo->sGame.seqCondition.capacity(); 找到一个bug，用size而不是capacity。
Vector的size和capacity的区别
Captain_MXD的博客
04-20 729
1.size指容器当前拥有的元素个数；     capacity则指容器在必须分配新存储空间之前可以存储的元素总数      2.容器调用resize()函数后，所有的空间都已经被初始了，而reserve()函数预分配出的空间没有被初始化 int main() { vector v; v.reserve(100); v.resize(10); f
C++ vector中capacity()和size() 的区别
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
11-14 844
size是指容器当前拥有元素的个数， capacity是指容器在必须分配新的存储空间之前可以存放的元素总数。
C++ Vector中size()和capacity（）区别
MusicMan
12-15 1830
简单而言，size（）指的是当前Vector中存放元素的大小，即他当前存放了多少个元素，capacity()指的是他能够存放多少个元素。 两个方法可以控制存放元素的大小和最大容纳数量 reserve可以保证容纳的大小 resize()可以设置当前存放元素的大小，但是不会改变前面已存放元素的值，这点来看，resize()是相当安全的一个函数方法，会默认设置外面的元素的值为空 实例代码 // Ve...
vector中的 size和 capacity和 reserve和 resize
tianshangyikexing的专栏
09-06 696
在vector中与size()和capacity() 相对应的有两个函数：resize(size_type)和reserve(size_type)。 Size指目前容器中实际有多少元素，对应的resize(size_type)会在容器尾添加或删除一些元素，来调整容器中实际的内容，使容器达到指定的大小。 Capacity指最少要多少元素才会使其容量重新分配，对应reserve(size_type
关于c++ vector capacity、max_size、size、sizeof的区别
jsqdzwy的博客
03-17 2991
capacity,如果不重新分配内存,当前已经分配的可以容纳的元素的个数. max_size最大的可能的元素个数. size是当前元素个数 sizeof是vector本身的大小（sizeof(vector)） size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共
STL容器中size和capacity的区别
qq_44778236的博客
02-29 718
size：表示当前容器中元素的个数 capacity：表示当前容器在必须分配新的存储空间之前允许存放元素的个数 与size对应的函数是resize(n),它的作用是调整容器的大小使其能够容纳n个元素，如果n小于当前容器的size，则删除多余的元素。如果n大于当前容器的size，则添加初始化后的元素。(resize还有另一种用法resize(n,0) 表示将所有新添加的元素初始化为0。） 与capa...
C++中vector的底层机制以及size和capacity的区别
DayDayUp
03-29 3158
vector底层机制 vector可以看做是一个动态的数组，是一段连续的线性内存空间。 它使用3个迭代器来表示： //_Alloc 表示内存分配器，此参数几乎不需要我们关心 template <class _Ty, class _Alloc = allocator<_Ty>> class vector{ ... protected: pointer _Myfirst; pointer _Mylast; pointer _Myend; }; .
C++ vector实现通讯录详解与示例
在本篇C++教程中，我们将深入探讨如何利用C++标准库中的容器vector来实现一个基本的通讯录功能。`vector` 是C++ STL（标准模板库）中的一个重要数据结构，它提供动态数组的功能，允许我们在运行时添加、删除和访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值