AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++】STL的基本用法

2024-02-01 220
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++】STL的基本用法


🌍1. STL概念

C++中的STL是指标准模板库的缩写。STL提供了一组通用的模板类和函数，用于实现常见的数据结构和算法，如向量（vector）、链表（list）、栈（stack）、队列（queue）、映射（map）等，以及包括排序、搜索、算法等在内的各种算法操作。

✨1.1 常见容器

  1. vector：动态数组，支持快速随机访问。
  2. list：双向链表，支持高效插入和删除操作。
  3. stack：栈，后进先出（LIFO）数据结构。
  4. queue：队列，先进先出（FIFO）数据结构。
  5. map：映射，键-值对的关联容器。

✨1.2 六大组件

  1. 容器（Containers）：容器是STL的核心组件之一，提供了各种数据结构，如向量（vector）、链表（list）、双端队列（deque）、栈（stack）、队列（queue）、映射（map）等。容器用于存储和组织数据，不同类型的容器适用于不同的数据访问和操作需求。
  2. 算法（Algorithms）：STL包含了一系列通用算法，用于操作容器中的数据，例如排序、查找、复制、变换等。这些算法是高度优化的，可适用于不同类型的容器，使开发人员能够更轻松地进行常见操作。
  3. 迭代器（Iterators）：迭代器是用于访问容器中元素的通用接口。它们提供了统一的方法来遍历容器，并使算法能够与不同类型的容器一起使用，而不需要了解底层容器的细节。
  4. 仿函数（Function Objects）：仿函数是可调用对象，它们在STL中用于执行特定操作，如排序或变换。STL提供了一些内置的仿函数，同时也允许开发人员定义自己的仿函数，以满足特定需求。
  5. 适配器（Adapters）：适配器是用于修改或扩展容器和迭代器行为的组件。STL中包括一些适配器，如栈适配器（stack adapter）和队列适配器（queue adapter），它们基于其他容器提供了不同的接口。
  6. 配置器（Allocators）：配置器用于管理内存分配和释放，以支持容器的底层数据结构。STL提供了默认的配置器，同时也允许开发人员自定义配置器以满足特定的内存管理需求。

🌍2.  STL容器之vector

✨2.1 vector

vector 是 C++ 标准库提供的一个动态数组容器，它可以自动扩展和收缩，使其非常适合存储和管理可变数量的元素。

传参

  1. 值传递
  2. 引用传递
  3. 指针传递

1. 值传递，调用Disp(v);

void Disp(vector<int> v){//值传递，不会修改原值
    for(int value:v){
        cout<<value<<" ";
    }
    cout<<endl;
    v.erase(v.begin()+1);
}

2. 引用类型，调用Disp(v);

void Disp(vector<int> &v){//引用传递，修改形参也会修改实参
    for(int value:v){
        cout<<value<<" ";
    }
    cout<<endl;
    v.erase(v.begin()+1);
}

3. 指针传递，调用Disp(&v);

void Disp(vector<int> *v){//指针传递，修改形参也会修改实参
    for(int value : *v){
        cout << value << " ";
    }
    cout << endl;
    v->erase(v->begin() + 1);
}

✨2.2 基本用法示例

⭐2.1 包含头文件

#include <vector>

⭐2.2 创建一个空的vector

vector<int> myVector;

⭐2.3 向vector 中添加元素

在使用 cin >> myVector[i]; 时，由于 myVector 是一个空的向量，尝试访问 myVector[i] 可能导致未定义的行为。因为在 for 循环中，你试图直接通过下标将输入的值存储到 myVector 中，但是 myVector 的大小为零，因此没有有效的索引。这可能导致程序崩溃或产生不可预测的结果。

myVector.push_back(42);
myVector.push_back(23);
myVector.push_back(17);
//输出：42 23 17
//错误示例
for(int i=0;i<n;i++){
    cin>>myVector[i];
}
//解决
for(int i=0;i<n;i++){
    int k;
    cin>>k;
    myVector.push_back(k);
}

⭐2.4 访问 vector 中的元素

int firstElement = myVector[0];
int secondElement = myVector[1];

⭐2.5 获取 vector 的大小

int size = myVector.size();

⭐2.6 遍历元素

//遍历方式一
for (int i = 0; i < myVector.size(); i++) {
    cout << myVector[i] << " ";
}
//遍历方式二
for (int value : myVector) {
    cout << value << " ";
}

⭐2.7 插入元素到指定位置

myVector.insert(myVector.begin() + 1, 100);  // 在myVertor[1]插入值为100的元素

⭐2.8 删除元素

注意：循环删除可能导致迭代器失效，可以使用范围删除。

myVector.erase(myVector.begin() + 1);  // 删除元素myVertor[1]
myVector.erase(myVector.begin() + m,myVector.end()); //删除v[m]~v[size-1]
/*错误示例*/
//去除nums1[m]后的元素
for(int i=m;i<nums1.size();i++){  //循环删除导致迭代器失效
    nums1.erase(nums1.begin()+i);
}
/*正确示例*/
nums1.erase(nums1.begin()+m,nums1.end());

⭐2.9 清空 vector

myVector.clear();

⭐2.10 示例程序

创建了一个 vector，向其中添加、插入、删除元素，并最后清空了vector。

#include <iostream>
#include <vector>
using namespace std;
void Disp(vector<int> &v){
    //输出方式一
    for(int value : v){
        cout << value << " ";
    }
    cout << endl;
    //输出方式二
    /*
    for(int i=0;i<v.size();i++){
        cout<<v[i]<<" ";
    }
    cout<<endl;
    */
}
int main(){
    //定义
    vector<int> v;
    //添加元素
    v.push_back(42);
    v.push_back(12);
    v.push_back(27);
    Disp(v);
    //释放元素
    v.erase(v.begin()+1);
    Disp(v);
    //插入元素
    v.insert(v.begin()+1,12);
    Disp(v);
    //size()大小
    cout<<v.size()<<endl;
    //删除
    //部分删除
    v.erase(v.begin(),v.end());
    //全部删除
    //v.clear();
    cout<<v.size()<<endl;
    return 0;
}

✨2.3 vector 的简化版源码示例

该简化的 MyVector 类模拟了 vector 的基本功能，包括动态数组的管理、元素的添加、访问和扩容等。

#include <iostream>
#include <stdexcept>
using namespace std;
template <typename T>
class MyVector {
private:
    T* data;        // 存储元素的数组
    size_t size;    // 当前元素数量
    size_t capacity; // 数组容量
public:
    // 构造函数
    MyVector() : data(nullptr), size(0), capacity(0) {}
    // 析构函数
    ~MyVector() {
        delete[] data; // 释放内存
    }
    // 返回元素数量
    size_t Size() const {
        return size;
    }
    // 添加元素到尾部
    void PushBack(const T& value) {
        if (size == capacity) {
            // 如果容量不足，扩展数组
            if (capacity == 0) {
                capacity = 1; // 初始容量为1
            } else {
                capacity *= 2; // 容量翻倍
            }
            T* newData = new T[capacity];
            for (size_t i = 0; i < size; ++i) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
        }
        data[size] = value; // 添加元素
        size++;
    }
    // 访问元素
    T& operator[](size_t index) {
        if (index < size) {
            return data[index];
        } else {
            throw out_of_range("Index out of range");
        }
    }
};
int main() {
    MyVector<int> myVector;
    myVector.PushBack(42);
    myVector.PushBack(23);
    myVector.PushBack(17);
    for (size_t i = 0; i < myVector.Size(); i++) {
        cout << myVector[i] << " ";
    }
    return 0;
}

🌍3. STL容器之map

✨3.1 map

在C++的STL（标准模板库）中，map是一种关联式容器，用于存储键-值对。它按照键的顺序进行排序，并且具有快速查找功能。

✨3.2 基本用法示例

⭐1. 包含头文件

#include <map>

⭐2. 创建一个空的map

map<string, int> myMap;

⭐3. 向 map 中插入键值对

myMap["Alice"] = 25;
myMap["Bob"] = 30;
myMap["Charlie"] = 35;

⭐4. 访问 map 中的值

int age = myMap["Alice"];

⭐5. 遍历输出

// 输出
for (auto it = myMap.begin(); it != myMap.end(); it++) {
    cout << it->first << ":" << it->second << endl;
}
// 使用迭代器遍历 map 中的键值对
for (const auto& pair : myMap) {
    cout << "Name: " << pair.first << ", Age: " << pair.second << endl;
}

⭐6. 检查 map 中是否包含特定的键

if (myMap.find("Alice") != myMap.end()) {
    cout << "Alice is in the map." << endl;
}

⭐7. 示例程序示例程序创建了一个 map，向其中添加键值对，访问键值对的值，并检查特定的键是否存在。

#include <iostream>
#include <map>
using namespace std;
void Disp(map<string,int> &m){
    //输出方式一
    for(auto it=m.begin();it!=m.end();it++){
        cout<<it->first<<" : "<<it->second<<endl;
    }
    //输出方式二
    /*
    for(const auto &p:m){
        cout<<p.first<<" : "<<p.second<<endl;
    }
    */
}
int main(){
    //定义
    map <string,int> m;
    //创建
    m["Alice"]=42;
    m["Ella"]=24;
    m["ackac"]=15;
    Disp(m);
    //查找相应值
    //没找到对应元素则返回m.end(),若该元素处在末尾则它的下个元素是m.end()
    if (m.find("Alice") != m.end()) {
        cout << "Alice is in the map." << endl;
    }
    else{
        cout << "Alice is't in the map." << endl;
    }
    //访问对应值
    int k=m["Alice"];
    cout<<k<<endl;
    return 0;
}

✨3.3 map的简化版源码示例

map 是 C++ 标准库提供的关联容器，它实际上是一个基于红黑树的有序关联容器，用于存储键值对，并能够按键的排序顺序进行访问。这个简化的 MyMap 类模拟了 map 的一些基本功能，包括插入和查找键值对。在实际的 map 实现中，还包括了红黑树平衡操作等，以确保高效的键值对查找和维护有序性。

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
    // 创建一个空的 map，用于存储名字和年龄的关联关系
    map<string, int> myMap;
    // 向 map 中插入键值对
    myMap["Alice"] = 25;
    myMap["Bob"] = 30;
    myMap["Charlie"] = 35;
    // 使用迭代器遍历 map 中的键值对
    for (const auto& pair : myMap) {
        cout << "Name: " << pair.first << ", Age: " << pair.second << endl;
    }
    // 访问特定键的值
    int age = myMap["Alice"];
    cout << "Alice's age is " << age << endl;
    // 检查特定键是否存在于 map 中
    if (myMap.find("Alice") != myMap.end()) {
        cout << "Alice is in the map." << endl;
    }
    return 0;
}

🌍4. STL容器之set

✨4.1 set

set是C++标准模板库[STL]中的一个关联容器，它提供了一种有序的、不重复的集合。set使用红黑树实现，这使得它的插入、删除和查找操作都具有较好的性能。

以下是set的一些关键特点：

  1. 有序性：set中的元素是按照严格的弱顺序排列的。默认情况下，元素按升序排序，但可以通过提供自定义的比较函数来实现不同的排序方式。
  2. 唯一性：set中不允许重复的元素，每个元素在集合中只能出现一次。
  3. 动态操作：set支持插入和删除操作，可以在运行时动态地改变集合的大小。
  4. 快速查找： 由于底层实现采用了红黑树，set提供了快速的查找操作。查找的平均复杂度是O(log n)。

✨4.2 基本用法示例

⭐2.1 包含头文件

#include <set>

⭐2.2 创建一个空的 set

set<int> mySet;

⭐2.3 向 set 中添加元素

没有mySet[i],不能像使用数组或类似容器（如vector）那样使用索引访问元素。set是基于红黑树实现的关联容器，它不提供通过索引直接访问元素的功能。因此，使用mySet[1]这样的语法会导致编译错误。

// 插入元素
mySet.insert(10);
mySet.insert(5);
mySet.insert(20);
mySet.insert(15);
//默认升序 5 10 15 20
set<int> mySet = {50,10,20,30,40};
//存储还是{10,20,30,40,50}

⭐2.4 获取 set的大小

int size = mySet.size();

⭐2.5 遍历元素

/*遍历方式*/
//遍历
for(int value :mySet){
   cout<<value<<" ";
}
cout<<endl;
// 使用迭代器遍历set中的元素
for (auto it = mySet.begin(); it != mySet.end(); it++) {
    cout << " " << *it;
}
cout << endl;
// 使用范围-based for 遍历
for (const auto& element : mySet) {
    cout << " " << element;
}
cout << endl;

⭐2.6 删除元素

set不支持通过迭代器的算术运算进行定位和删除元素。因为 set 是一个关联容器，它的元素是按照某种比较准则有序排列的，而不是按照它们在容器中的物理位置排列的。

mySet.erase(15);//删除值为15的元素
//mySet.erase(mySet.begin()+1); is error!

⭐2.7 查找find()

返回值：

  • 如果找到元素，返回指向该元素的迭代器。
  • 如果未找到元素，返回容器的 end 迭代器。

注意：如果找到的元素在最后一个，返回的则不是end迭代器!

#include <iostream>
#include <set>
using namespace std;
int main() {
    set<int> mySet = {50,10,20,30,40};
    // 使用 find 查找元素
    set<int>::iterator it = mySet.find(30);//返回的是迭代器对象，未找到则返回mySet.end()
    // 检查是否找到
    if (it != mySet.end()) {
        cout << "元素 30 找到了，位置是：" << distance(mySet.begin(), it) << endl;
    } else {
        cout << "元素 30 未找到。" << endl;
    }
    return 0;
}
/*输出：
元素 30 找到了，位置是：2
*/

⭐2.8 清空 set

mySet.clear();

⭐2.9 示例程序

#include <iostream>
#include <set>
using namespace std;
void Disp(set<int> s){
    //遍历方式一
    for(int value:s){
        cout<<value<<" ";
    }
    cout<<endl;
    //遍历方式二
    /*
    for (auto it = s.begin(); it != s.end(); it++) {
        cout<< *it << " ";
    }
    cout << endl;
    //遍历方式三
    for (const auto& it : s) {
        cout<< it << " ";
    }
    cout << endl;
    */
}
int main(){
    //定义
    set <int> s;
    //插入
    s.insert(42);
    s.insert(24);
    s.insert(12);
    Disp(s);
    //再次定义,原来的值被删除
    s={4,11,22,33,55,66,77};
    Disp(s);
    //输出
    s.erase(4);
    Disp(s);
    //size()
    cout<<s.size()<<endl;
    //查找
    set<int>::iterator it = s.find(30);//返回的是迭代器对象，未找到则返回mySet.end()
    if (it != s.end()) {
        cout << "元素 30 找到了，位置是：" << distance(s.begin(), it) << endl;
    } 
    else {
        cout << "元素 30 未找到。" << endl;
    }
    //清空
    s.clear();
    cout<<s.size()<<endl;
    return 0;
}

文章标签：
C++
容器
算法
存储
索引
关键词：
C++ stl
C++用法
SarPro
目录
相关文章
ephemerals__
|
7月前
|
编译器 C++ 容器
【c++丨STL】基于红黑树模拟实现set和map（附源码）
本文基于红黑树的实现，模拟了STL中的`set`和`map`容器。通过封装同一棵红黑树并进行适配修改，实现了两种容器的功能。主要步骤包括：1) 修改红黑树节点结构以支持不同数据类型；2) 使用仿函数适配键值比较逻辑；3) 实现双向迭代器支持遍历操作；4) 封装`insert`、`find`等接口，并为`map`实现`operator[]`。最终，通过测试代码验证了功能的正确性。此实现减少了代码冗余，展示了模板与仿函数的强大灵活性。
ephemerals__
184 2
oioihoii
|
10月前
|
存储 安全 编译器
第二问：C++中const用法详解
`const` 是 C++ 中用于定义常量的关键字，主要作用是防止值被修改。它可以修饰变量、指针、函数参数、返回值、类成员等，确保数据的不可变性。`const` 的常见用法包括：
oioihoii
367 2
ephemerals__
|
7月前
|
存储 算法 C++
【c++丨STL】map/multimap的使用
本文详细介绍了STL关联式容器中的`map`和`multimap`的使用方法。`map`基于红黑树实现，内部元素按键自动升序排列，存储键值对，支持通过键访问或修改值；而`multimap`允许存在重复键。文章从构造函数、迭代器、容量接口、元素访问接口、增删操作到其他操作接口全面解析了`map`的功能，并通过实例演示了如何用`map`统计字符串数组中各元素的出现次数。最后对比了`map`与`set`的区别，强调了`map`在处理键值关系时的优势。
ephemerals__
353 73
平凡程序猿~
|
8月前
|
存储 缓存 C++
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
C++ 标准模板库（STL）提供了一组功能强大的容器类，用于存储和操作数据集合。不同的容器具有独特的特性和应用场景，因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说，了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器，包括序列容器（`std::vector`、`std::array`、`std::list`、`std::deque`）、关联容器（`std::set`、`std::map`）和无序容器（`std::unordered_set`、`std::unordered_map`），全面解析它们的特点、用法
平凡程序猿~
402 1
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
ephemerals__
|
7月前
|
存储 算法 C++
【c++丨STL】set/multiset的使用
本文深入解析了STL中的`set`和`multiset`容器，二者均为关联式容器，底层基于红黑树实现。`set`支持唯一性元素存储并自动排序，适用于高效查找场景；`multiset`允许重复元素。两者均具备O(logN)的插入、删除与查找复杂度。文章详细介绍了构造函数、迭代器、容量接口、增删操作（如`insert`、`erase`）、查找统计（如`find`、`count`）及`multiset`特有的区间操作（如`lower_bound`、`upper_bound`、`equal_range`）。最后预告了`map`容器的学习，其作为键值对存储的关联式容器，同样基于红黑树，具有高效操作特性。
ephemerals__
289 3
ephemerals__
|
8月前
|
存储 算法 C++
【c++丨STL】priority_queue（优先级队列）的使用与模拟实现
本文介绍了STL中的容器适配器`priority_queue`（优先级队列）。`priority_queue`根据严格的弱排序标准设计，确保其第一个元素始终是最大元素。它底层使用堆结构实现，支持大堆和小堆，默认为大堆。常用操作包括构造函数、`empty`、`size`、`top`、`push`、`pop`和`swap`等。我们还模拟实现了`priority_queue`，通过仿函数控制堆的类型，并调用封装容器的接口实现功能。最后，感谢大家的支持与关注。
ephemerals__
402 1
ephemerals__
|
9月前
|
C++ 容器
【c++丨STL】stack和queue的使用及模拟实现
本文介绍了STL中的两个重要容器适配器：栈（stack）和队列（queue）。容器适配器是在已有容器基础上添加新特性或功能的结构，如栈基于顺序表或链表限制操作实现。文章详细讲解了stack和queue的主要成员函数（empty、size、top/front/back、push/pop、swap），并提供了使用示例和模拟实现代码。通过这些内容，读者可以更好地理解这两种数据结构的工作原理及其实现方法。最后，作者鼓励读者点赞支持。 总结：本文深入浅出地讲解了STL中stack和queue的使用方法及其模拟实现，帮助读者掌握这两种容器适配器的特性和应用场景。
ephemerals__
191 21
平凡程序猿~
|
8月前
|
存储 算法 C++
深入浅出 C++ STL：解锁高效编程的秘密武器
C++ 标准模板库（STL）是现代 C++ 的核心部分之一，为开发者提供了丰富的预定义数据结构和算法，极大地提升了编程效率和代码的可读性。理解和掌握 STL 对于 C++ 开发者来说至关重要。以下是对 STL 的详细介绍，涵盖其基础知识、发展历史、核心组件、重要性和学习方法。
平凡程序猿~
131 0
ephemerals__
|
10月前
|
编译器 C语言 C++
【c++丨STL】list模拟实现（附源码）
本文介绍了如何模拟实现C++中的`list`容器。`list`底层采用双向带头循环链表结构，相较于`vector`和`string`更为复杂。文章首先回顾了`list`的基本结构和常用接口，然后详细讲解了节点、迭代器及容器的实现过程。 最终，通过这些步骤，我们成功模拟实现了`list`容器的功能。文章最后提供了完整的代码实现，并简要总结了实现过程中的关键点。 如果你对双向链表或`list`的底层实现感兴趣，建议先掌握相关基础知识后再阅读本文，以便更好地理解内容。
ephemerals__
206 1
ephemerals__
|
10月前
|
算法 C语言 C++
【c++丨STL】list的使用
本文介绍了STL容器`list`的使用方法及其主要功能。`list`是一种双向链表结构，适用于频繁的插入和删除操作。文章详细讲解了`list`的构造函数、析构函数、赋值重载、迭代器、容量接口、元素访问接口、增删查改操作以及一些特有的操作接口如`splice`、`remove_if`、`unique`、`merge`、`sort`和`reverse`。通过示例代码，读者可以更好地理解如何使用这些接口。最后，作者总结了`list`的特点和适用场景，并预告了后续关于`list`模拟实现的文章。
ephemerals__
324 7