STL容器类【C++基础】

Xiunneg

已于 2023-09-09 14:42:01 修改

阅读量112

点赞数

分类专栏： CPP 文章标签： c++ 开发语言

于 2023-09-09 14:09:04 首次发布

本文链接：https://blog.csdn.net/Xiunneg/article/details/132776706

版权

CPP 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

STL容器类

文章源地址：修能的博客

STL（标准模板库）提供了一组通用的数据结构和算法，其中包含了很多容器类。C++的STL容器类包括：

vector（向量）：动态数组，支持随机访问和动态大小调整。
list（链表）：双向链表，支持快速插入和删除。
deque（双端队列）：双向队列，支持快速在两端插入和删除。
queue（队列）：先进先出（FIFO）队列，支持在一端插入，在另一端删除。
stack（栈）：后进先出（LIFO）栈，支持在一端插入和删除。
set（集合）：有序集合，每个元素都唯一，支持插入、删除和查找操作。
map（映射）：由键和值成对组成的集合，键唯一且有序，支持插入、删除和查找操作。
unordered_set（无序集合）：无序集合，每个元素都唯一，支持插入、删除和查找操作，查找速度较快。
unordered_map（无序映射）：由键和值成对组成的无序集合，键唯一，支持插入、删除和查找操作，查找速度较快。

这些容器类提供了不同的功能和性能特点，可以根据需求选择适合的容器类来存储和操作数据。

vector

动态数组，支持随机访问和动态大小调整。

构造方法

默认构造方法：创建一个空的 vector 对象。
```
vector<int> v
```
带有元素数量和初始值的构造方法：创建一个包含指定数量元素的 vector，每个元素都被初始化为指定的值。
```
std::vector<int> v(5, 10);
```

带有迭代器范围的构造方法：使用迭代器表示的范围内的元素来创建一个 vector。

std::vector<int> sourceVector {1, 2, 3, 4, 5};
std::vector<int> myVector(sourceVector.begin(), sourceVector.end());

拷贝构造方法：使用另一个 vector 对象的副本来创建一个新的 vector。

std::vector<int> sourceVector {1, 2, 3, 4, 5};
std::vector<int> myVector(sourceVector);

移动构造方法：使用另一个 vector 对象的内容来创建一个新的 vector，同时移动原始对象的内容到新对象中。
```
std::vector<int> sourceVector {1, 2, 3, 4, 5};
std::vector<int> myVector(std::move(sourceVector));
```
std::move() 是 C++ 标准库中的一个函数模板，它用于将对象的状态从一个对象移动到另一个对象，而无需执行深拷贝。这个函数在移动语义中起着重要的作用。

成员函数

push_back()：向 vector 的末尾添加一个元素。void push_back(const T& value)
```
vector<int> v = {1};
v.push_back(2);
Disp(v);
```
```
1,2
```
pop_back()：从 vector 的末尾删除一个元素。void pop_back()
```
vector<int> v = {1,2};
v.pop_back();
Disp(v);
```
```
1
```

size()：返回 vector 中元素的数量。size_type size() const

vector<int> v = {1,2};
Disp(v);
cout << v.size();

1 2
1

empty()：检查 vector 是否为空。bool empty() const

vector<int> v;
printf("%s",v.empty()?"empty\n":"unempty\n");
v.push_back(1);
printf("%s",v.empty()?"empty\n":"unempty\n");

empty
unempty

at()：访问指定索引处的元素，并进行边界检查。 const T& at(size_type index) const
```
vector<int> v = {1,2,3,4,5,6};
cout << v.at(0) << endl;
```
```
1
```

clear()：移除 vector 中的所有元素。void clear()

vector<int> v = {1,2,3,4,5,6};
printf("%s",v.empty()?"empty\n":"unempty\n");
v.clear();
printf("%s",v.empty()?"empty\n":"unempty\n");

unempty
empty

insert()：在指定位置插入一个或多个元素。iterator insert(iterator position, const T& value)

vector<int> v = {1,3,4,5,6};
Disp(v);
v.insert(v.begin()+1,2);
Disp(v);

1 3 4 5 6
1 2 3 4 5 6

vector<int> v = {1};
Disp(v);
v.insert(v.begin()+1,5,1);
Disp(v);

1
1 1 1 1 1 1

erase(): 移除指定位置的元素。iterator erase(iterator position)

vector<int> v = {1,2};
Disp(v);
v.erase(v.begin());
Disp(v);

1 2
2

resize(): 改变vector的大小。void resize(size_type count)

std::vector<int> myVector {1, 2, 3};

std::cout << "Current size: " << myVector.size() << std::endl;

// 增大向量的大小为 5，并使用默认值 0 初始化新的元素
myVector.resize(5);

std::cout << "New size after resizing: " << myVector.size() << std::endl;

// 输出向量中的元素
std::cout << "Vector elements: ";
for (const auto& element : myVector) {
	std::cout << element << " ";
}
std::cout << std::endl;

Current size: 3
New size after resizing: 5
Vector elements: 1 2 3 0 0

reserve()：提前分配足够的内存空间以容纳指定数量的元素。void reserve(size_type new_cap)

当知道向量可能会包含一定数量的元素时，可以使用 reserve() 成员函数来预先分配足够的内存空间，以避免不必要的重新分配和复制。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> myVector;

    std::cout << "Current capacity: " << myVector.capacity() << std::endl;

    // 预分配足够的空间以容纳 10 个元素
    myVector.reserve(10);

    std::cout << "New capacity after reserving: " << myVector.capacity() << std::endl;

    // 向向量中添加元素
    for (int i = 1; i <= 5; ++i) {
        myVector.push_back(i);
    }

    // 输出向量中的元素
    std::cout << "Vector elements: ";
    for (const auto& element : myVector) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

Current capacity: 0
New capacity after reserving: 10
Vector elements: 1 2 3 4 5

list

双向链表，支持快速插入和删除。

构造函数：

默认构造函数：list()

带有初始元素的构造函数：list(std::initializer_list<T> il) 或者 list(size_type count, const T& value)

list<int> myList1(10);
Disp(myList1);
list<int> myList2(10,1);
Disp(myList2);

0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1

范围构造函数：template <class InputIterator> list(InputIterator first, InputIterator last)
```
list<int> myList1(10);
Disp(myList1);
list<int>::iterator it = next(myList1.begin(),2);
advance(it,3);
list<int> myList2(myList1.begin(),it);
Disp(myList2);
```
```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
```
std::next() 是 C++ 标准库中的一个函数模板，位于 <iterator> 头文件中。它用于获取迭代器的下一个位置，并将其返回。

std::advance() 是 C++ 标准库中的一个函数模板，位于 <iterator> 头文件中。它用于将迭代器向前或向后移动指定的步数。

拷贝构造函数：list(const list& other)

list<int> myList1(10);
list<int> myList2(myList1);
Disp(myList2);

成员函数(与vector有重复的)

front()：返回list中第一个元素的引用。
back()：返回list中最后一个元素的引用。

deque

双向队列，支持快速在两端插入和删除。

构造函数：

默认构造函数：deque()
创建一个空的deque容器。
带有大小参数的构造函数：deque(size_type count, const T& value = T())
创建一个包含count个值为value的元素的deque容器。
范围构造函数：deque(InputIterator first, InputIterator last)
创建一个包含[first, last)范围内元素的deque容器，其中first和last分别为指向范围起始和结束位置的迭代器。

成员函数：

大小和容量操作：
- size()：返回deque中元素的个数。
- empty()：判断deque是否为空。
- max_size()：返回deque能够容纳的最大元素数量。
迭代器相关操作：
- begin()：返回指向deque第一个元素的迭代器。
- end()：返回指向deque末尾元素的下一个位置的迭代器。
- rbegin()：返回指向deque末尾元素的逆向迭代器。
- rend()：返回指向deque第一个元素的前一个位置的逆向迭代器。
元素访问：
- front()：返回deque中第一个元素的引用。
- back()：返回deque中最后一个元素的引用。
- operator：访问指定位置上的元素。
修改容器内容：
- assign(InputIterator first, InputIterator last)：用[first, last)范围内的元素替换deque的内容。
- push_back(const T& value)：将value添加到deque的末尾。
- pop_back()：删除deque的最后一个元素。
- push_front(const T& value)：将value添加到deque的开头。
- pop_front()：删除deque的第一个元素。
- insert(iterator pos, const T& value)：在pos位置之前插入value。
- erase(iterator pos)：删除pos位置处的元素。
- clear()：清空deque的内容。

stack

后进先出（LIFO）栈，支持在一端插入和删除。

构造函数：

默认构造函数：stack()
创建一个空的stack容器。
拷贝构造函数：stack(const stack& other)
根据另一个stack容器other创建一个新的stack容器，包含相同的元素。

成员函数：

大小和容量操作：
- size()：返回stack中元素的个数。
- empty()：判断stack是否为空。
元素访问：
- top()：返回stack顶部元素的引用。
修改容器内容：
- push(const T& value)：将value添加到stack的顶部。
- pop()：移除stack顶部的元素。

set/unordered_set

有序集合，每个元素都唯一，支持插入、删除和查找操作。

无序集合，每个元素都唯一，支持插入、删除和查找操作。

构造函数：

默认构造函数：set()
创建一个空的set容器，默认使用元素类型的默认比较函数进行排序。
范围构造函数：set(InputIterator first, InputIterator last)
创建一个包含[first, last)范围内唯一元素的set容器，其中first和last分别为指向范围起始和结束位置的迭代器。
```
vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
```
```
1 2 3 4 5 6 7
```

拷贝构造函数：set(const set& other)
根据另一个set容器other创建一个新的set容器，包含相同的元素。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
    set<int> s(v.begin(),v.end());
    Disp(s);
    set<int> s1(s);
    Disp(s1);

1 2 3 4 5 6 7
1 2 3 4 5 6 7

成员函数：

大小和容量操作：
- size()：返回set中元素的个数。
- empty()：判断set是否为空。

插入和删除元素：

insert(const T& value)：将value插入到set中，如果已存在于set中，则不会插入。
```
set<int> mySet;
Disp(mySet);
mySet.insert(1);
Disp(mySet);
```
```
1
```

erase(const T& value)：从set中删除与value相等的元素。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
s.erase(2);
Disp(s);

1 2 3 4 5 6 7
1 3 4 5 6 7

clear()：清空set的内容。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
s.clear();
Disp(s);

1 2 3 4 5 6 7

查找元素：

find(const T& value)：返回指向set中与value相等的元素的迭代器，如果找不到则返回end()迭代器。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
auto it = s.find(2);
auto it1 = s.find(10);
cout << *it << endl;
cout < *it1 << endl;

1 2 3 4 5 6 7
2
7

count(const T& value)：返回set中与value相等的元素的个数，即0或1。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
cout << s.count(2) << endl;
cout << s.count(10) << endl;

1 2 3 4 5 6 7
1
0

upper_bound(const T& value)：返回指向set中第一个大于value的元素的迭代器。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
set<int> s(v.begin(),v.end());
Disp(s);
auto it = s.upper_bound(4);
cout << *it << endl;

1 2 3 4 5 6 7
5

lower_bound(const T& value)：返回指向set中第一个大于或等于value的元素的迭代器。

vector<int> v = {1,2,2,3,3,3,4,4,4,5,6,7,7,7};
    set<int> s(v.begin(),v.end());
    Disp(s);
    auto it = s.lower_bound(4);
    cout << *it << endl;

1 2 3 4 5 6 7
4

迭代器相关操作：
- begin()：返回指向set中第一个元素的迭代器。
- end()：返回指向set中最后一个元素的下一个位置的迭代器。
- rbegin()：返回指向set中最后一个元素的逆向迭代器。
- rend()：返回指向set中第一个元素的前一个位置的逆向迭代器。

map/unordered_map

map（映射）：由键和值成对组成的集合，键唯一且有序，支持插入、删除和查找操作。unordered_set（无序集合）：无序集合，每个元素都唯一，支持插入、删除和查找操作，查找速度较快。

构造函数：

默认构造函数：map()
创建一个空的map容器，默认使用键类型的默认比较函数进行排序。
范围构造函数：map(InputIterator first, InputIterator last)
创建一个包含[first, last)范围内键值对的map容器，其中的每个键值对都是唯一的。
拷贝构造函数：map(const map& other)
根据另一个map容器other创建一个新的map容器，包含相同的键值对。

成员函数：

大小和容量操作：
- size()：返回map中键值对的个数。
- empty()：判断map是否为空。

插入和删除元素：

insert(const value_type& value)：插入一个键值对value到map中，如果已存在相同的键，则键值对不会插入。

template <typename Key,typename Value>
void Disp(map<Key, Value> Map)
{
    for (auto Mypair : Map)
    {
        cout << Mypair.first << ":" << Mypair.second << endl;
    }
}

int main()
{
    map<char, int> Map;

    Map.insert(pair<char,int>('a',10));
    Map.insert(pair<char,int>('b',32));

    Disp(Map);
    return 0;
}

erase(const key_type& key)：从map中删除指定键的键值对。

map<char, int> Map;

Map.insert(pair<char,int>('a',10));
Map.insert(pair<char,int>('b',32));

Map.erase('b');

Disp(Map);

a:10

clear()：清空map的内容。

查找元素：

find(const key_type& key)：返回指向map中与key相等的键值对的迭代器，如果找不到则返回end()迭代器。

map<char, int> Map;

Map.insert(pair<char, int>('a', 10));
Map.insert(pair<char, int>('b', 32));
auto it = Map.find('a');
cout << (*it).first <<  ":" << (*it).second <<endl;

a:10

count(const key_type& key)：返回map中与key相等的键的个数，即0或1。

 map<char, int> Map;

Map.insert(pair<char, int>('a', 10));
Map.insert(pair<char, int>('b', 32));
cout << Map.count('a') << endl;

访问元素：

operator[](const key_type& key)：通过键访问对应的值，如果键不存在，则会创建一个新键值对并返回对应的值。

map<char, int> Map;

Map.insert(pair<char, int>('a', 10));
Map.insert(pair<char, int>('b', 32));
Disp(Map);
    
cout << Map['a'] << endl;
cout << Map['c'] << endl;

Disp(Map);

a:10
b:32
10
0
a:10
b:32
c:0

迭代器相关操作：
- begin()：返回指向map中第一个键值对的迭代器。
- end()：返回指向map中最后一个键值对的下一个位置的迭代器。
- first：访问键对值的Key。
- second：访问键对值的Value

Xiunneg

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
STL容器类【C++基础】

STL（标准模板库）提供了一组通用的数据结构和算法，其中包含了很多容器类。vector（向量）list（链表）queue（队列）stack（栈）set（集合）map（映射）这些容器类提供了不同的功能和性能特点，可以根据需求选择适合的容器类来存储和操作数据。
复制链接

扫一扫