【 C++ 】vector的常用接口说明

1、vector介绍

vector是表示可变大小数组的序列容器。

就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小。为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

2、vector的使用

2.1、vector的定义

（constructor）构造函数声明****接口说明1、vector() 重点无参构造2、vector（size_type n, const value_type& val = value_type()）构造并初始化n个val3、vector (const vector& x); （重点）拷贝构造4、vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造
示例：

1、vector() 无参构造
int main()
{
    vector<int> v1;//存储int类型数据
    v1.push_back(1);
    vector<double> v2;
    v2.push_back(1.1);//存储double类型数据
    vector<string> v3;
    v3.push_back("hello world");//存储string类型数据
}
2、vector（size_type n, const value_type& val = value_type()）构造并初始化n个val
vector<int> v1(10, 5);//用10个5来初始化v1
3、vector (const vector& x); 拷贝构造
vector<int> v1(10, 5);//用10个5来初始化v1
vector<int> v2(v1);//用v1去拷贝构造v2
4、vector (InputIterator first, InputIterator last); 使用迭代器进行初始化构造
vector<int> v1(10, 5);//用10个5来初始化v1
vector<int> v3(v1.begin(), v1.end());//使用迭代器拷贝构造v2的数据
还可以通过迭代器初始化来获得string的字符串
string s = "hello world";
vector<char> v(s.begin(), s.end());

2.2、vector的遍历

接口名称****使用说明1、operator[ ]下标 + [ ]2、迭代器begin + end 或 rbrgin + rend3、范围for底层还是借用迭代器实现

operator[ ]

operator[ ]就是对[ ]的重载，是我们可以像C语言那样使用下标 + [ ]去访问元素。
void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        v[i] += 1;
        cout << v[i] << " "; // 2 3 4 5
    }
}

迭代器

vector的迭代器和string的迭代器近乎一致，规则也都类似。
iterator的使用****接口说明1、begin + end
begin获取第一个数据位置的iterator/const_iterator，

end获取最后一个数据的下一个位置的iterator/const_iterator
2、rbegin + rend
rbegin获取最后一个数据位置的reverse_iterator，

rend获取第一个数据前一个位置的reverse_iterator

正向迭代器：
void test2()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    //2、迭代器
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        *it -= 2;
        cout << *it << " "; // -1 0 1 2
        it++;
    }
}
反向迭代器：
void test()
{
    vector<int> v(10, 5);
    vector<int>::reverse_iterator rit = v.rbegin();
    while (rit != v.rend())
    {
        cout << *rit << " ";
        rit++;
    }
}

范围for

范围for的底层就是替换了迭代器，先前string类已经实现过。

3、范围for
void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    //3、范围for
    for (auto e : v)
    {
        cout << e << " "; //1 2 3 4
    }
}

2.3、vector的空间增长问题

容量空间****接口说明1、size获取数据个数2、capacity获取容量大小3、max_size判断是否为空4、resize改变vector中的size5、reserve改变vector的capacity

size和capacity

vector的size是用来获取有效数据个数，而capacity就是获取容量大小：
void test()
{
    vector<int> v(7, 5);
    cout << v.size() << endl;//7
    cout << v.capacity() << endl;//5
}

max_size

max_size的作用是返回vector容器可以容纳的最大元素数，用类型的最大值除以sizeof(类型）即max_size。
void test()
{
    vector<int> v1;
    cout << v1.max_size() << endl;//1073741823
    vector<char> v2;
    cout << v2.max_size() << endl;//2147483647
}

reserve

reserve的作用是请求更改容量capacity。

如果 n 大于当前容量，则该函数会导致容器重新分配其存储，将其容量增加到 n（或更大）。

在所有其他情况下，函数调用不会导致重新分配，且容量不会受影响。
void test()
{
    vector<int> v(10, 5);
    cout << v.capacity() << endl;//10
    //如果n > 当前容量大小，更新容量至n
    v.reserve(100);
    cout << v.capacity() << endl;//100
    //如果n < 当前容量大小，不做出任何改动
    v.reserve(20);
    cout << v.capacity() << endl;//100
}
补充：
void test()
{
    size_t sz;
    std::vector<int> foo;
    sz = foo.capacity();
    std::cout << "making foo grow:\n";
    for (int i = 0; i < 100; ++i) 
    { 
        foo.push_back(i);
        if (sz != foo.capacity()) 
        {
            sz = foo.capacity();
            std::cout << "capacity changed: " << sz << '\n';
        }
    }
}
测试结果如下：

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。vs是PJ版本STL，g++是SGI版本STL。

为什么一定要按照1.5倍或2倍增长呢？

答案：合适，单次增容越多，插入N个值，增容次数越少，效率就越高，但是浪费空间就越多。单次增容越少，就会导致频繁增容，效率低下。1.5倍或2倍是最平衡的做法。

resize

resize在空间的同时也进行了初始化。

如果 n 小于当前容器大小，则内容将减少到其前 n 个元素，删除超出（并销毁）的元素。

如果 n 大于当前容器大小，则通过在末尾插入所需数量的元素以达到 n 的大小来扩展内容。如果指定了 val，则新元素将初始化为 val 的副本，否则，它们将进行值初始化。
void test()
{
    vector<int> v(10, 5);
    cout << v.size() << endl;//10
    cout << v.capacity() << endl;//10
    //如果n的大小 > size和capacity，更新到n。超出的部分用1初始化
    v.resize(100, 1);
    cout << v.size() << endl;//100
    cout << v.capacity() << endl;//100
    //如果n的大小 < size，更新size到n，容量capacity不变
    v.resize(50);
    cout << v.size() << endl;//50
    cout << v.capacity() << endl;//100
    //如果n的大小 > size，且 < capacity，更新size到n，容量capacity不变
    v.resize(70);
    cout << v.size() << endl;//50
    cout << v.capacity() << endl;//100
}

2.4、vector的增删查改

vector增删查改****接口说明1、push_back尾插2、pop_back尾删3、insert在下标为pos的前面插入val4、erase删除下标为pos的值1、find查找。（注意这个是算法模块实现，不是vector的成员接口）2、sort排序。（注意这里也不是vector的函数接口，只是用于排序）

push_back和pop_back

这俩接口和string类以及数据结构的没啥区别，这里简单给出测试用例：
void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(10);
    v.pop_back();
    v.pop_back();
}

insert和erase

insert就是在下标为pos的前面插入val，erase就是删除下标为pos的值

void test9()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(10);
//insert
    v.insert(v.begin(), 0); //在下标为0的位置插入0
    v.insert(v.begin(), 2, -1);//在下标为0的位置往后插入两个-1
    for (auto e : v)
        cout << e << " "; //-1 -1 0 1 10
    cout << endl;
    v.insert(v.begin() + 3, 2);//在下标为3的位置插入2
    for (auto e : v)
        cout << e << " "; //-1 -1 0 2 1 10
    cout << endl;
//erase
    v.erase(v.begin()); //头删
    for (auto e : v)
        cout << e << " "; //-1 0 2 1 10
    cout << endl;
    v.erase(v.begin() + 3); //删除下标为3的值
    for (auto e : v)
        cout << e << " "; //-1 0 2 10
    cout << endl;
    //删除在该迭代器区间内的元素（左闭右开）
    v.erase(v.begin(), v.begin() + 3);//删除下标[0, 3)左闭右开的值
    for (auto e : v)
        cout << e << " ";//10
}

find

这里的find并不是vector的成员函数，这个是算法模块实现。其本质就是在一段左闭右开的迭代器区间去寻找一个值。找到了就返回它的迭代器，找不到就返回它的开区间那个迭代器。
void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    //vector<int>::iterator pos = find(v.begin(), v.end(), 3);
    auto pos = find(v.begin(), v.end(), 3);//调用find在左闭右开的区间内寻找val
    if (pos != v.end())
    {
        cout << "找到了" << endl;
        v.erase(pos);//找到后，把该值删掉
    }
    else
    {
        cout << "没有找到" << endl;
    }
    for (auto e : v)
        cout << e << " "; //1 2 4
}

sort

sort函数也不是vector的成员函数，这里只是为了对vector创建的数据进行排序。

void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(-23);
    v.push_back(30);
    v.push_back(9);
    v.push_back(0);
    v.push_back(-90);
//默认sort是升序
    sort(v.begin(), v.end());
    for (auto e : v)
        cout << e << " "; //-90 -23 0 1 9 30
    cout << endl;
//要排降序，就要用到仿函数,具体是啥后续详谈
    sort(v.begin(), v.end(), greater<int>());
    for (auto e : v)
        cout << e << " "; //30 9 1 0 -23 -90
}

标签： c++ 开发语言 vector

本文转载自: https://blog.csdn.net/bit_zyx/article/details/125690334
版权归原作者 三分苦 所有，如有侵权，请联系我们删除。