C++容器篇，vector容器

CHAK&MING

已于 2023-01-20 11:58:43 修改

阅读量3.4k

点赞数 8

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

于 2022-10-23 09:08:04 首次发布

本文链接：https://blog.csdn.net/chakming1/article/details/127470727

版权

C++ 专栏收录该内容

20 篇文章 23 订阅

订阅专栏

C++容器篇——vector容器

1 vector的介绍和使用

1.1 vector的介绍

vector的参考文档

vector是C++最常用的容器之一，其本质是动态增长的数组。而vector是C++六大组件之一的容器，容器时存放数据的一些数据结构。vector比常用数组的好处在于，我们可以动态的改变大小，并且无需预先分配指定的大小。

vector的尾部插入和删除的效率很高，达到了常数级别的时间复杂度。并且支持随机访问。不过对于不在末尾的插入删除，效率较低。

1.2 vector的使用

vector必须包含头文件#include <vector>，并且属于std命名空间里面。

int main()
{
	vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);
	vec.push_back(5);

	for (size_t i = 0; i < vec.size(); ++i)
	{
		cout << vec[i] << " ";
	}	
	cout << endl;
}

这是一个简单的使用vector容器的案例，首先先创建一个vector容器，<int>这里表示我这个容器存放的是int类型的数据。然后通过push_back()来在这个容器末尾插入元素，我们在使用的时候无需关心他的容量是否足够。

最后，我们通过一个for循环来遍历容器，并打印容器中的每一个数据。

1.2.1 vector的定义

vector的构造函数：

构造函数	接口说明
vector();	无参构造
vector (size_type n, const value_type& val = value_type());	有参构造
vector (const vector& x);	拷贝构造
vector (InputIterator first, InputIterator last);	迭代器构造

第一个是无参构造，这个时候容器里面并没有存放任何数据。但是需要通过<>来指定容器存放的类型。
第二个是构造并初始化，初始化n个为val的容器。其实构造函数还有一个空间适配器allocator，这里暂时先忽略。
第三个是拷贝构造。
第四个可能暂时很难理解，其实是通过迭代器来构造并初始化。

int main()
{
	vector<int> vec1;
	vector<int> vec2(10, 1);
	vector<int> vec3(vec2);
	vector<int> vec4(vec2.begin(), vec2.end());
}

1.2.2 vector的迭代器

迭代器其实本质上是指针，但是是对指针进行了封装。我们在使用C语言的时候，常常因为指针，甚至多级指针，导致代码异常复杂难看。容器里的迭代器对指针进行改造之后，使用起来更加方便。vector中迭代器其实就是原生指针。因为vector无论是遍历元素，还是访问或者修改元素，都只需要普通的指针就可以完成。

那么，为什么指针能完成的事情，cpp还需要在上面包装成一个迭代器呢，这是因为C++中不止包含了一种容器，其他容器可能需要对指针进行更加复杂的操作。那这个时候，使用容器用户，无需关心内部的实现细节。并且，在之后使用算法，也能够体会到迭代器的好处。

vector获取迭代器：

迭代器的使用	使用说明
begin()	返回指向开始位置的迭代器
end()	返回指向末尾元素的下一个位置的迭代器
cbegin()	返回指向开始并且为常量的迭代器
cend()	返回指向末尾元素的下一个位置的并且为常量的迭代器
rbegin()	返回逆置迭代器，指向末尾元素下一个位置，操作都是往相反反向
rend()	返回逆置迭代器，指向开头元素的位置，操作都是往相反反向
crbegin()	返回逆置迭代器，指向末尾元素下一个位置，操作都是往相反反向，并且为常量属性
crend()	返回逆置迭代器，指向开头元素的位置，操作都是往相反反向，并且为常量属性

$(img-GzW2PS7m-1666487058843)(D:\C++2.0\C++语法\image\image-20221023081023995.png)]$
在这里插入图片描述

begin()返回指向开始位置的迭代器，end()返回指向容器最后一个元素下一个位置的迭代器。
rbegin()和rend()与begin()和end()相反。
这里先把迭代器当成指向对应位置的指针，通过对迭代器进行解引用，获取对应的值。

int main()
{
	vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);
	vec.push_back(5);

	auto it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

1.2.3 vector的空间增长问题

容量说明	接口说明
size	获取容器中实际的个数
maxsize (无用)	获取容量中最大可以存放多少个元素
capacity	获取容器中可以存放数据的容量
empty	判断是否为空
resize（重点）	改变容器的size
reserve（重点）	改变容器的容量
shrink_to_fit	将容器的容量的值调整为和大小一样

这里要说明的一点是，vector容器的容量与实际的大小是不一样的，并且容量的增长根据编译器不同，实现也有所差异，vs下的capacity是按1.5倍增长，g++是按两倍增长的。

reserve是负责开辟空间，如果确定知道需要用多少空间，可以提前开辟好，防止vector增容带来的开销和缺陷问题。

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

// 测试vector的默认扩容机制
void TestVectorExpand()
{
    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);
        if (sz != v.capacity())
    	{
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
		}
	}
}

测试结果：

vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141

g++运行结果：linux下使用的STL基本是按照2倍方式扩容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128

如果已经确定vector要存储元素的大概个数，可以提前将空间设置好，就可以防止扩容所带来的问题。

void TestVectorExpandOP()
{
    vector<int> v;
    size_t sz = v.capacity();
    v.reserve(100); // 提前将容量设置好，可以避免一遍插入一遍扩容
    cout << "making bar 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';
		}
	}
}

与容量相关的成员函数使用方法：

int main()
{
    vector<int> v = {1, 2, 3, 4, 5, 6, 7};
    cout << v.size() << endl; // 7
    cout << v.max_size() << endl; // 2305843009213693951
    cout << v.capacity() << endl; // 7
    cout << v.empty() << endl; // 0

    v.resize(20);
    cout << v.size() << endl; // 20
    cout << v.capacity() << endl; // 20 容量会随着大小变动而变动
    v[15] = 3;
    // 遍历一遍vector
    for (const auto &i : v)
        cout << i << " "; // 1 2 3 4 5 6 7 0 0 0 0 0 0 0 0 3 0 0 0 0
    cout << endl;

    v.reserve(100);
    cout << v.capacity() << endl; //100


    v.shrink_to_fit(); // size和capacity一致
    cout << v.size() << endl; // 20
    cout << v.capacity() << endl; // 20
}

1.2.4 vector增删改查

增删改查	接口说明
push_back	尾插一个元素
pop_back	尾删一个元素
find	查找（这是配合算法函数，并不是vector的成员函数）
insert	在指定位置插入val
erase	删除指定位置的数据
swap	交换两个vector的数据空间
operator[]	可以像数组一样访问元素

vector的增删改查，从名字上也能够很好猜测其含义，下面是相关代码演示：

emplate<typename T>
void print_vector(const vector<T> &v)
{
    for (const auto &i : v)
        cout << i << " ";
    cout << endl;
}

int main()
{
    vector<int> v;

    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);

    print_vector(v); // 1 2 3 4

    v.pop_back();
    v.pop_back();

    print_vector(v); // 1 2

    auto it = find(v.begin(), v.end(), 1);

    v.insert(it, 3);
    v.insert(it, 4);
    print_vector(v); // 4 3 1 2


    v.erase(it);
    print_vector(v); // 3 1 2

    vector<int> v2{1, 3, 5, 7, 9};
    v.swap(v2);
    print_vector(v); // 1 3 5 7 9
    print_vector(v2); // 3 1 2

    // operator[]
    for (int i = 0; i < v.size(); i++) 
    {
        cout << v[i] << " "; // 1 3 5 7 9
        cout << v.at(i) << " "; // 与上面一致
    }
    cout << endl;
}

1.2.5 vecotr迭代器失效问题

迭代器的主要作用是算法可以不用关心底层实现的细节，然后对所有容器的操作都统一做了封装，其底层都是一个指针，只是实现有所差异。比如：vector的迭代器就是原始指针T*。所谓迭代器失效，其实就是在进行了某些操作之后，导致迭代器对应的指针所指向的空间被销毁了，导致使用一块已经被释放的空间，从而导致程序崩溃。

失效的场景一：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1,2,3,4,5,6};
    auto it = v.begin();
    // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
    // v.resize(100, 8);
    // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
    // v.reserve(100);
    // 插入元素期间，可能会引起扩容，而导致原空间被释放
    // v.insert(v.begin(), 0);
    // v.push_back(8);
    // 给vector重新赋值，可能会引起底层容量改变
    v.assign(100, 8);
    /*
    出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
    而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
    空间，而引起代码运行时崩溃。
    解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
    赋值即可。
    */
    while(it != v.end())
    {
        cout<< *it << " " ;
        ++it;
    }
    cout<<endl;
    return 0;
}

失效的场景二：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    int a[] = { 1, 2, 3, 4 };
    vector<int> v(a, a + sizeof(a) / sizeof(int));
    // 使用find查找3所在位置的iterator
    vector<int>::iterator pos = find(v.begin(), v.end(), 3);
    // 删除pos位置的数据，导致pos迭代器失效。
    v.erase(pos);
    cout << *pos << endl; // 此处会导致非法访问
    return 0;
}

这里失效的原因是，我们通过查找函数获得了3元素指向的迭代器，然后对这个位置进行删除，那么删除之后，原本这个迭代器指向的位置会被销毁，从而导致迭代器失效。

失效场景三：

#include <string>
void TestString()
{
    string s("hello");
    auto it = s.begin();
    // 放开之后代码会崩溃，因为resize到20会string会进行扩容
    // 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
    // 后序打印时，再访问it指向的空间程序就会崩溃
    //s.resize(20, '!');
    while (it != s.end())
    {
        cout << *it;
        ++it;
    }
    cout << endl;
    it = s.begin();
    while (it != s.end())
    {
        it = s.erase(it);
        // 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
        // it位置的迭代器就失效了
        // s.erase(it);
        ++it;
    }
}

那么，如果遇到失效的场景，就通过操作之后，获取它的返回值，来保证迭代器失效的问题。

2 vector的深度解剖及模拟实现

本书借鉴了《STL源码剖析》这本书，里面对STL的源码有很详细的介绍，虽然使用的版本是GCC2.9。但并不影响我们了解其底层，与现在版本有所差异，但旧版本的实现，更加容易了解。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ig39sqPX-1666487058845)(D:\C++2.0\C++语法\image\image-20221023085759711.png)]$
在这里插入图片描述

2.1 vector的模拟实现代码

// vector.hpp
//
// Created by 17660 on 2022/9/2.
//

#ifndef TEST_09_02_VECTOR_H
#define TEST_09_02_VECTOR_H

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cassert>


namespace ming {
    template<class T>
    class vector {
    public:
        typedef T *iterator;
        typedef const T *const_iterator;
        iterator begin(){
            return start;
        }
        iterator end(){
            return finish;
        }
        const_iterator cbegin() const{
            return start;
        }
        const_iterator cend() const{
            return finish;
        }
        vector() : start(nullptr), finish(nullptr), endofstorage(nullptr) {}

        ~vector() {
            delete[] start;
            start = finish = endofstorage = nullptr;
        }

        // capacity
        size_t size() const {
            return (finish != nullptr && start != nullptr) ? finish - start : 0;
        }

        size_t capacity() const {
            return (endofstorage != nullptr && start != nullptr) ? endofstorage - start : 0;
        }

        void reserve(size_t n) {
            if(n > capacity()){
                T* tmp = new T(n);
                size_t sz = size();
                if(start != nullptr) {
                    memcpy(tmp, start, sizeof(T) * size());
                    delete[] start;
                }
                start = tmp;
                finish = start + sz;
                endofstorage = start + n;
            }
        }

        ///access///
        T& operator[](size_t pos){
            assert(pos < size());
            return start[pos];
        }
        const T& operator[](size_t pos)const{
            assert(pos < size());
            return start[pos];
        }

        // modify
        void push_back(const T &value) {
            if (finish == endofstorage) {
                reserve(capacity() == 0 ? 4 : capacity() * 2);
            }
            *finish = value;
            ++finish;
        }

        void pop_back() {
            assert(finish > start);
            --finish;
        }

        iterator insert(iterator pos, const T &value) {
            assert(pos >= start || pos < finish);
            if (finish == endofstorage) {
                size_t len = pos - start;
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                pos = start + len;
            }
            // 挪动数据
            iterator end = finish - 1;
            while(end >= pos){
                *(end + 1) = *end;
                --end;
            }
            *pos = value;
            ++finish;
            return pos;
        }
        iterator erase(iterator pos) {
            assert(pos >= start || pos < finish);
            iterator begin = pos + 1;
            while(begin < finish){
                *(begin + 1) = *begin;
                ++begin;
            }
            --finish;
            return pos;
        }

    private:
        iterator start;
        iterator finish;
        iterator endofstorage;
    };
}

#endif //TEST_09_02_VECTOR_H