C++第二十弹---深入理解STL中vector的使用

最新推荐文章于 2024-06-15 18:06:06 发布

小林熬夜学编程

最新推荐文章于 2024-06-15 18:06:06 发布

阅读量1.1k

点赞数 154

分类专栏： C++详解文章标签： c++ 开发语言 c语言算法

本文链接：https://blog.csdn.net/2201_75584283/article/details/137172697

版权

C++详解专栏收录该内容

25 篇文章 8 订阅

订阅专栏

✨个人主页：熬夜学编程的小林

💗系列专栏：【C语言详解】【数据结构详解】【C++详解】

1、vector的介绍

vector文档介绍https://cplusplus.com/reference/vector/vector/

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

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

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

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

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

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

2、vector的使用

vector学习时一定要学会查看文档：vector的文档介绍，vector在实际中非常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口是要重点掌握的。

2.1、构造函数和赋值重载

2.1.1、构造函数的介绍

1. Default constructor (default (1)):

explicit vector (const allocator_type& alloc = allocator_type());

这是 std::vector 的空容器构造函数(默认构造函数)。它构造一个没有元素的空容器。可选参数 alloc 是一个分配器对象，用于指定内存分配模型（后面会学到）。explicit 关键字表示构造函数防止隐式转换或复制初始化。大多数时候，你可以简单地省略分配器，因为它有一个默认值。

2. Fill constructor (fill (2)):

explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());

这是 std::vector 的填充构造函数。这个构造函数构造了一个含有 n 个元素的容器，每个元素都是 val 的副本。val 是可选的；如果不提供，则使用该类型的默认构造函数创建元素。同样，alloc 是可以省略的可选分配器。explicit 关键字仅在只提供了 n 参数的情况下有作用，当同时提供 n 和 val 时，可以使用复制初始化。

3. Range constructor (range (3)):

template <class InputIterator>
vector (InputIterator first, InputIterator last,
        const allocator_type& alloc = allocator_type());

这是 std::vector 的范围构造函数。这个构造函数使用两个迭代器 first 和 last，这两个迭代器指定了一个序列的范围，来构造一个容器。这个范围包括从 first 到 last 之间的所有元素，但不包括 last 指向的元素。这个构造函数可以用于复制任何其他容器（如 list、deque、甚至是另一个 vector）中的元素。分配器 alloc 是可选的。

4. Copy constructor (copy (4)):

vector (const vector& x);

这是 std::vector 的赋值(拷贝)构造函数。构造一个容器，其中包含 x 中每个元素的副本，顺序相同。

5. copy

 vector& operator= (const vector& x);

这是 std::vector 的赋值操作符重载。将新内容分配给容器，替换其当前内容，并相应地修改其大小。

2.1.2、代码演示

#include<iostream>
#include<vector>
using namespace std;

int main()
{
    //1.默认构造函数
    vector<int> v;
    //2.填充构造函数
    vector<int> v1(5, 1);//构造n个元素，初始化为1
    //3.范围构造函数
    vector<int> v2(v1.begin(), v1.end());//构造v1的起始位置到结束为止，左闭右开
    //4.拷贝构造函数
    vector<int> v3(v2);//将v2数组的元素拷贝给v3
    //5.赋值操作符重载
    vector<int> v4 = v3;//将v3数组的元素拷贝给v3

    //使用范围for打印
    for (auto x : v)
    {
        cout << x << " ";
    }
    cout << endl;
    for (auto x : v1)
    {
        cout << x << " ";
    }
    cout << endl;
    for (auto x : v2)
    {
        cout << x << " ";
    }
    cout << endl;
    for (auto x : v3)
    {
        cout << x << " ";
    }
    cout << endl;
    for (auto x : v4)
    {
        cout << x << " ";
    }
    cout << endl;
    return 0;
}

2.2、容量操作

size_t size();

获取数组的大小。

size_t capacity()

获取数组的容量。

int main()
{
    vector<int> v(10, 1);
    cout << "size() = " << v.size() << endl;//大小
    cout << "capacity() = " << v.capacity() << endl;//容量
    return 0;
}

看看扩容机制：

int main()
{
    size_t sz;
    vector<int> v;
    sz = v.capacity();//初始容量
    cout << "making v grow:\n";
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);//尾插一个元素i
        if (sz != v.capacity())//初始容量与现在容量不相等则更新
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';//修改后的容量
        }
    }
    return 0;
}

vs结果如下:

vs下使用的STL基本是按照1.5倍方式扩容。

g++结果如下：

linux下使用的STL基本是按照2倍方式扩容。

reserve(size_t n)

更改容量。

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

在所有其他情况下，函数调用不会导致重新分配(无需扩容)，并且向量容量不受影响。

用来预先开辟容量大小，来减少扩容次数：

int main()
{
    vector<int> v;
    size_t sz = v.capacity();
    v.reserve(100); // 将容量扩大至100，开辟100个数的空间
    cout << "making reserve grow:\n";
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
        }
    }
    return 0;
}

测试结果：

resize()

调整容器的大小，使其包含 n 个元素。

如果 n 小于当前容器大小，则内容将减少到其前 n 个元素，删除超出（并销毁它们）的元素。
如果 n 大于当前容器大小，则通过在末尾插入所需数量的元素来扩展内容，以达到 n 的大小。如果指定了 val，则新元素将初始化为 val 的副本，否则，它们将进行值初始化。
如果 n 也大于当前容器容量，则会自动重新分配分配的存储空间(即需要扩容)。

int main()
{
    vector<int> v;
    v.resize(10, 1);//调整大小为10，并初始化为1
    for (auto x : v)
    {
        cout << x << " ";
    }
    cout << endl;
    return 0;
}

测试结果：

总结：

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题(细节)。

resize在开空间的同时还会进行初始化，影响size。

resize不会进行缩容，如果想要缩容，我们可以调用shrink_to_fit()函数。

2.3、遍历

operator[ ](size_t n)

获取下标为n的元素。

int main()
{
    vector <int> v1(10, 1);
    for (size_t i = 0; i < v1.size(); i++)
    {
        cout << v1[i] << " ";//重载[]遍历数组
    }
    cout << endl;
    return 0;
}

测试结果：

迭代器iterator

begin();指向第一个元素。

end();指向最后一个元素的下一个。

rbegin();指向最后一个元素的下一个。

rend();指向第一个元素。

int main()
{
    vector<int> v(10, 1);
    vector<int>::iterator it = v.begin();//迭代器返回类型
    while (it != v.end())//使用迭代器遍历数组
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}

测试结果：

2.4、增删改

push_back();

在末尾添加元素。
在数组的末尾添加一个新元素(在当前最后一个元素之后)。val 的内容将被复制（或移动）到新元素。

这实际上将容器大小增加了一个，当且仅当新的向量大小超过当前向量容量时，才会自动重新分配分配的存储空间。

pop_back();

删除最后一个元素。
删除数组中的最后一个元素，从而有效地将容器大小减小一个。

int main()
{
    vector<int> v;
    v.push_back(1);//尾插1
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (auto x : v)//打印数组
    {
        cout << x << " ";
    }
    cout << endl;
    v.pop_back();//尾删
    v.pop_back();
    for (auto x : v)
    {
        cout << x << " ";
    }
    return 0;
}

测试结果：

insert();

插入元素。
通过在指定位置的元素之前插入新元素来扩展向量，从而有效地通过插入的元素数量增加容器大小。C++98重载了三种插入方式。

1. Single element (1):

iterator insert (iterator position, const value_type& val);

这个方法在数组中 position 指定的位置前插入一个 val 副本，并返回指向新插入元素的迭代器。如果 position 是向量的 end() 迭代器，则新元素被添加到向量的末尾(尾插)。

2. Fill (2):

void insert (iterator position, size_type n, const value_type& val);

这个方法在 position 指定的位置前插入 n 个 val 副本。它不返回任何值。

3. Range (3):

template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);

这个方法将位于 [first, last) 区间内的元素插入到 position 指定的位置前。这个范围包括 first，但不包括 last，即它是一个半开区间。这个方法也不返回任何值。

举例：

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	for (auto x : v)
	{
		cout << x << " ";
	}
	cout << endl;
	auto it = v.begin();
	it = v.insert(it, 10);//在1之前插入10
	for (auto x : v)
	{
		cout << x << " ";
	}
	cout << endl;
	it = v.insert(it, 2, 20);//在10之前插入两个20
	for (auto x : v)
	{
		cout << x << " ";
	}
	cout << endl;
	vector<int> v1;
	//在v1第一个位置插入v数组
	v1.insert(v1.begin(), v.begin(), v.end());
    return 0;
}

测试结果：