C++语言基础：STL----vector 、deque-优快云博客

本文链接：https://blog.youkuaiyun.com/changlif/article/details/124593037

本文深入探讨了C++ STL中的vector和deque容器。介绍了它们的基本概念、构造函数、赋值操作、容量与大小、插入与删除、数据存取以及两者之间的区别。重点讲解了vector的动态扩展策略和deque的双端操作特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2、STL常用容器

2.1、string

2.2、vector

2.2.1、vector基本概念
- 1、功能：vector 数据结构和数组非常相似，也称为单端数组
- 2、vector与普通数组的区别：
  - 不同之处在于数组是静态空间，vector可以扩展
- 3、动态扩展：
  - 并不是元空间之后续接新空间，而是找更大的内存空间，然后拷贝新空间，释放原空间
  - 提供两种方法：
    - 1. 尾插：push_back()
    - 2. 尾删：pop_back()
- 4、vector迭代器支持随机访问

2.2.2、vector构造函数

1、功能描述：创建vector容器

2、函数原型
- 1. vector<T> v; //1. 模板实现类实现，默认构造函数
- 2. vector(v.begin(), v.end()); //2.将（v.begin(), v.end()）区间中的元素拷贝给本身
- 3. vector(n, elem); // 3.将n个elem拷贝给vector
- 4. vector(const vector & vec); // 4.拷贝构造函数

3、示例

void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

void test01() {
    vector<int> v1;//1. 模板实现类实现，默认构造函数
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    printVector(v1);  // 0 1 2 3 4 5 6 7 8 9
    vector<int> v2(v1.begin(), v1.end());//2.将 （v.begin(), v.end()）区间中的元素拷贝给本身
    printVector(v2);  // 0 1 2 3 4 5 6 7 8 9
    vector<int> v3(10, 100);// 3.构造函数将n个elem拷贝给vector
    printVector(v3);  // 100 100 100 100 100 100 100 100 100 100
    vector<int> v4(v3);// 4.拷贝构造函数
    printVector(v4);  // 100 100 100 100 100 100 100 100 100 100
}

2.2.3、vector赋值操作

1、功能：给vector容器进行赋值

2、函数原型
- 1. vector& operator=(const vector & vec); // 1.重载等号操作符
- 2. assign(beg, end); // 2.将[beg, end)区间的数据拷贝赋值给vector本身
- 3. assign(n, elem); // 3.将n个elem拷贝赋值给本身

3、示例

void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
void test01() {
    vector<int> v1;
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    printVector(v1); // 0 1 2 3 4 5 6 7 8 9
    vector<int> v2;
    v2 = v1; //1.重载等号操作符
    printVector(v2); // 0 1 2 3 4 5 6 7 8 9
    vector<int> v3;
    v3.assign(v1.begin(), v1.end()); //2.将[beg, end)区间的数据拷贝赋值给vector本身
    printVector(v3);  // 0 1 2 3 4 5 6 7 8 9
    vector<int> v4;
    v4.assign(10, 2);// 3.将10个2拷贝赋值给本身
    printVector(v4); // 2 2 2 2 2 2 2 2 2 2 
}

2.2.4、vector容量和大小

1、函数原型
- 1. empty(); // 判断容器是否为空
- 2. capacity(); // 容器的容量
- 3. size(); // 返回容器中元素的个数（capacity() >= size()）
- 4. resize(int num); // 重新指定容器的长度，如果容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
- 5. resize(int num, elem); // 重新指定容器的长度，如果容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

2、示例

void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
void test01() {
    vector<int> v1;
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    printVector(v1); // 0 1 2 3 4 5 6 7 8 9
    if (!v1.empty()) { // 1.判空
        cout << "capacity = " << v1.capacity() << endl; //capacity = 13  // 容器的容量
        cout << "size = " << v1.size() << endl; //size = 10  // 容器的元素个数
    }
    v1.resize(15);// 新增的位置用0填充
    printVector(v1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
    v1.resize(17, 99);// 新增的位置用0填充
    printVector(v1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 99 99
}

2.2.5、vector插入和删除

1、函数原型
- 1. push_back(ele); // 尾部插入元素ele
- 2. pop_back(); // 删除最后一个元素
- 3. insert(const_iterator pos, ele); //向指定位置pos插入元素ele，注意是插入，并非替换
- 4. insert(const_iterator pos, int count, ele); //向指定位置pos插入count个元素ele
- 5. erase(const_iterator pos); // 删除地带器执行的元素
- 6. erase(const_iterator start, const_iterator end); // 删除迭代器从start到end 之间的元素
- 7. clear(); // 删除容器中所有的元素

2、示例

void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
void test01() {
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50); 
    printVector(v1); // 10 20 30 40 50
    v1.pop_back(); // 删除尾部
    printVector(v1); // 10 20 30 40 

    v1.insert(v1.begin(), 99); // 插入，第一个参数是迭代器
    printVector(v1); // 99 10 20 30 40 

    v1.insert(v1.begin(), 3, 100); // 插入3个100，第一个参数是迭代器
    printVector(v1); // 100 100 100 99 10 20 30 40 

    v1.erase(v1.begin()); // 删除第一个元素，参数是迭代器
    printVector(v1); // 100 100 99 10 20 30 40 

    v1.erase(v1.begin(), v1.begin() + 2); // 删除前两个元素
    printVector(v1); // 99 10 20 30 40 

    v1.clear(); // 清空容器
    printVector(v1); // 空 
}

2.2.6、vector数据的存取

1、函数原型
- 1. at(int idx); // 返回索引idx所值的数据
- 2. operator[]; // 返回索引idx所值的数据
- 3. front(); // 返回容器第一个元素
- 4. back(); // 返回最后一个元素

2、示例

void test01() {
    vector<int> v1;
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    int a = v1.at(1);// 返回第二个元素
    int b = v1[1]; // 返回第二个元素
    int first = v1.front(); // 返回第一个元素
    int last = v1.back(); // 返回最后一个元素
}

2.2.7、vector互换容器

1、函数原型
- 1. swap(vec); // 将vec与本函数的元素互换

2、示例

void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
void test01() {
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
        v2.push_back(i + 10);
    }
    printVector(v1); // 0 1 2 3 4 5 6 7 8 9
    printVector(v2); // 10 11 12 13 14 15 16 17 18 19
    v2.push_back(0);
    printVector(v2); // 10 11 12 13 14 15 16 17 18 19 0

    v1.swap(v2); // vector互换容器
    printVector(v1); // 10 11 12 13 14 15 16 17 18 19 0
    printVector(v2); // 0 1 2 3 4 5 6 7 8 9

    vector<int>(v1).swap(v1); // 收缩空间，vector(v1)是一个匿名对象
    printVector(v1); // 10 11 12 13 14 15 16 17 18 19 0 
}

2.2.8、vector预留空间
- 1、功能描述：减少vector在动态扩展容量是的扩展次数
- 2、函数原型
  - reserve（int len）; // 容器预留len个元素的长度，预留位置不初始化，元素不可访问
- 3、示例
  - vector<int> v;
  - v.reserve(10000); // 预留10000个元素的长度

2.3、deque
- 2.3.1、deque基本概念
  - 1、功能
    - 双端数组，可以对头和尾进行插入删除操作
  - 2、deque与vector的区别
    - 1. vector对于头部的插入删除效率低，数据量越大，效率越低
    - 2. deque相对而言，对头部的插入删除速度会比vector快
    - 3. vector访问元素时的速度会比deque快，这和两者内部实现有关
  - 3、deque内部工作原理：
    - 1. deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
    - 2. 中控器维护的是每个缓冲区的地址，是的使用deque时就像一片连续的内存空间
  - 4、deque迭代器支持随机访问
  - 5、头文件：#include <deque>
- 2.3.2、deque构造函数
  - 1、函数原型
    - 1. deque<T> deqT; // 1.默认构造形式
    - 2.deque(beg, end); // 将[)区间的元素拷贝构造
    - 3. deque(n, elem); // 构造函数将n个elem拷贝给本身
    - 4. deque(const deque &deq); // 拷贝构造
  - 2、示例
    - ```
    void printDeque(deque<int>& v) {
        for (deque<int>::iterator it = v.begin(); it != v.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
    }
    void test01() {
        deque<int> d1;
        for (int i = 0; i < 10; i++) {
            d1.push_back(i);
        }
        printDeque(d1); // 0 1 2 3 4 5 6 7 8 9
    
        deque<int> d2(d1.begin(), d1.end());// 2.区间初始化
        printDeque(d2); // 0 1 2 3 4 5 6 7 8 9
    
        deque<int> d3(6, 10); // 3.6个10初始化
        printDeque(d3); // 10 10 10 10 10 10
    
        deque<int> d4(d3); // 4.拷贝构造
        printDeque(d4); // 10 10 10 10 10 10
    }
```
- 2.3.3、deque赋值操作
  - 1、函数原型
    - 1. deque& operator=(const deque & deq); // 重载等号操作符
    - 2. assign(beg, end); // 将[)区间赋值给deque
    - 3. assign(n, elem); // 将n个elelm拷贝赋值给本身
  - 2、示例
    - ```
    void printDeque(deque<int>& v) {
        for (deque<int>::iterator it = v.begin(); it != v.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
    }
    void test01() {
        deque<int> d1;
        for (int i = 0; i < 10; i++) {
            d1.push_back(i);
        }
        printDeque(d1); // 0 1 2 3 4 5 6 7 8 9
    
        deque<int> d2;
        d2 = d1; // 1.等号赋值
        printDeque(d2); // 0 1 2 3 4 5 6 7 8 9
    
        deque<int> d3;
        d3.assign(d1.begin(), d1.end());// 2.区间赋值
        printDeque(d3); // 0 1 2 3 4 5 6 7 8 9
    
        deque<int> d4;
        d4.assign(6, 10);// 3.6个10初始化
        printDeque(d4); // 10 10 10 10 10 10
    }
```
- 2.3.4、deque容量和大小
  - 1、函数原型
    - 1. empty(); // 判断容器是否为空
    - 2. size(); // 返回容器中元素的个数(没有容量的概念，可以无限往deque中放数据)
    - 3. resize(int num); // 重新指定容器的长度，如果容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
    - 4. resize(int num, elem); // 重新指定容器的长度，如果容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
  - 2、示例
    - ```
    void printDeque(deque<int>& v) {
        for (deque<int>::iterator it = v.begin(); it != v.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
    }
    void test01() {
        deque<int> d1;
        for (int i = 0; i < 10; i++) {
            d1.push_back(i);
        }
        if (!d1.empty()) {
            cout << "deque的大小：" << d1.size() << endl; // deque的大小：10
        }
        printDeque(d1); // 0 1 2 3 4 5 6 7 8 9
    
        d1.resize(15);//指定容器大小，多余的用0填充
        printDeque(d1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
    
        d1.resize(18, 99);//指定容器大小，多余的用99填充
        printDeque(d1); // 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 99 99 99
    }
```
- 2.3.5、deque插入和删除
  - 函数原型
  - 两端插入、删除操作
    - 1. push_back(ele); // 尾部插入元素ele
    - 2. push_front(ele); // 头部插入元素ele
    - 3. pop_back(); // 删除最后一个元素
    - 4. pop_front(); // 删除第一个元素
  - 两端插入、删除操作
    - 5. insert(const_iterator pos, ele); //向指定位置pos插入元素ele，注意是插入，并非替换
    - 6. insert(const_iterator pos, int count, ele); //向指定位置pos插入count个元素ele
    - 7. insert(const_iterator pos, int begin, int end); //向指定位置pos插入区间[begin, end)的元素
    - 8. erase(const_iterator pos); // 删除pos位置的元素，返回下一个元素的位置
    - 9. erase(const_iterator start, const_iterator end); // 删除迭代器从[start,end)之间的元素，返回下一个元素的位置
    - 10. clear(); // 删除容器中所有的元素
- 2.3.6、deque数据的存取
  - 1、函数原型
    - 1. at(int idx); // 返回索引idx所值的数据
    - 2. operator[]; // 返回索引idx所值的数据
    - 3. front(); // 返回容器第一个元素
    - 4. back(); // 返回最后一个元素
- 2.3.7、deque排序
  - 1、函数原型
    - sort(iterator begin, iterator end); // 对区间[)内元素进行排序