C++STL容器

vector篇：动态数组，可在O(1)时间内访问元素，支持快速尾部插入和删除操作，但在中间插入或删除操作可能较慢。内存分配方式为连续空间，故可通过指针直接访问数据。

#include <vector>

// 使用默认构造函数创建一个空的 vector
std::vector<int> vec;

// 创建一个大小为 10，初值为 0 的 vector
std::vector<int> vec1(10, 0);

// 创建一个包含 {1, 2, 3, 4, 5} 的 vector
std::vector<int> vec2 = {1, 2, 3, 4, 5};

// 从现有的数组或另一个 vector 中拷贝元素创建一个新的 vector
int arr[] = {1, 2, 3, 4, 5};
//arr 和 arr + 5 分别表示一个数组的起始位置和结束位置这条语句的作用是将数组 arr 中的前 5 个元素拷贝到一个新的 vector 对象中
std::vector<int> vec3(arr, arr + 5);
std::vector<int> vec4(vec2.begin(), vec2.end());

// 访问第 i 个元素
int value = vec[i];

// 第二个元素
int second = myVec.at(1); 

// 修改第 i 个元素的值
vec[i] = new_value;

// 使用迭代器遍历 vector
#include <iterator> // 包含迭代器相关头文件
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl;
}

//使用下标来遍历vector 
for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }

//使用at()来遍历vector 
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec.at(i) << " ";
    }

// 在末尾添加一个元素
vec.push_back(value);

// 在指定位置插入一个元素
vec.insert(vec.begin() + index, value);
// 在 vector 的第三个元素（即元素值为 3）之前插入元素 100
vec.insert(vec.begin() + 2, 100);

// 删除末尾的一个元素
vec.pop_back();

// 删除指定位置的一个元素
vec.erase(vec.begin() + index);


// 获取 vector 中的元素个数
int size = vec.size();

// 获取 vector 的容量大小
int capacity = vec.capacity();

// 修改 vector 的大小
vec.resize(new_size);
std::vector<int> vec = {1, 2, 3, 4, 5};
    
// 修改 vector 的大小为 10，多出的元素都设置为 0
vec.resize(10, 0);

// 修改 vector 的容量    
vec.reserve(new_capacity);
 // 修改 vector 的容量为 20
vec.reserve(20);


// 对 vector 进行升序排序
std::sort(vec.begin(), vec.end());

// 查找 vector 中是否包含指定元素
//std::find 会在容器的起始迭代器和终止迭代器之间查找第一个等于该值的元素，并返回一个指向该元素的迭代器。如果容器中不存在该元素，则返回终止迭代器（表示不包括任何元素的范围）
if (std::find(vec.begin(), vec.end(), value) != vec.end()) {
    // 找到了 value
}

// 去除 vector 中的重复元素
std::sort(vec.begin(), vec.end());
//std::unique 函数的作用是去除重复的元素。它会将相邻的重复元素中的后一个元素删除，然后返回指向新的（不包含重复元素）范围的结尾迭代器。
vec.erase(std::unique(vec.begin(), vec.end()), vec.end());

deque篇：双端队列，既可以在开头和结尾快速插入和删除元素，也支持高效的随机访问，但相对于vector来说处理起来稍微慢一些。

#include <deque>

std::deque<int> d; // 使用默认构造函数创建空的 deque

std::deque<int> d1(10); // 创建包含 10 个元素的 deque，默认值为0

std::deque<int> d2(10, 1); // 创建包含 10 个元素的 deque，所有元素初始值都为1

std::deque<int> d {1, 2, 3};

d.push_back(4); // 向 deque 的末尾添加元素 4

d.push_front(0); // 向 deque 的头部添加元素 0

d.pop_back(); // 删除 deque 的末尾元素

d.pop_front(); // 删除 deque 的头部元素

std::deque<int> d {1, 2, 3};

int x = d[0]; // 获取 deque 的第一个元素

int y = d.at(1); // 获取 deque 的第二个元素

for (auto it = d.begin(); it != d.end(); ++it) {
        std::cout << *it << " ";
    }

QList篇：双向链表，可在任意位置进行快速插入和删除操作，但不能像vector那样高效地随机访问元素。每个元素包含前后指针，因此需要更多的内存来存储链表本身。

#include <iostream>
#include <QtCore/QList>

int main() {
    QList<int> list;

    // 头尾插入元素
    list.prepend(1);
    list.append(2);
    list.append(3);

    // 使用 [] 运算符访问元素
    std::cout << "Element at index 0: " << list[0] << std::endl;

    // 使用 at() 函数访问元素
    std::cout << "Element at index 1: " << list.at(1) << std::endl;

    // 获取列表大小
    std::cout << "List size: " << list.size() << std::endl;

    // 遍历列表
    for (int i = 0; i < list.size(); ++i) {
        std::cout << list.at(i) << " ";
    }
    std::cout << std::endl;

    // 删除元素
    list.removeOne(2);

    // 遍历列表（使用迭代器）
    for (QList<int>::const_iterator it = list.begin(); it != list.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 清空列表
    list.clear();

    return 0;
}

QStack篇：堆栈，只能在栈顶插入和删除元素，遵循先进后出的原则。实现方式通常采用deque或list。

#include <QStack>
QStack<int> stack; // 创建一个存储 int 类型元素的栈对象

stack.push(1); // 将元素 1 压入栈中
stack.push(2); // 将元素 2 压入栈中

int size = stack.size();  // 此时 size 的值为 2

int topElement = stack.top(); // 获取栈顶元素，此时 topElement 的值为 2

stack.pop(); // 弹出栈顶元素，此时栈中仅剩元素 1

int size = stack.size(); // 获取栈大小，此时 size 的值为 1

bool isEmpty = stack.isEmpty(); // 判断栈是否为空，此时 isEmpty 的值为 false

//遍历栈中的元素：
while(!stack.isEmpty()) {
    int element = stack.pop();
    // 处理元素
}

QQueue篇：队列，可在队列前面插入元素，在队列尾部删除元素，遵循先进先出的原则。实现方式也通常采用deque或list。

#include <QQueue>

QQueue<int> queue; // 创建一个存储 int 类型元素的 queue 对象

//通过 enqueue() 函数把元素插入队列中：
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);

int size = queue.size();  // 此时 size 的值为 3

int headElement = queue.head(); // 此时 headElement 的值为 10

queue.dequeue(); // 现在从队列中移除了元素 10
// 现在队列中剩余两个元素，20 和 30

bool isEmpty = queue.isEmpty(); // 此时 isEmpty 的值为 false

foreach(int element, queue) {
    // 处理元素
}

queue.clear(); // 清空队列中所有元素

Qset篇：自动排序并去重的容器，查找、插入和删除操作的时间复杂度均为O(logN)。

#include <QSet>

QSet<int> set; // 创建一个存储 int 类型元素的 set 对象

//使用 insert() 函数插入元素
set.insert(10);
set.insert(20);
set.insert(30);

int size = set.size(); // 此时 size 的值为 3

//使用 contains() 函数判断集合中是否包含某个元素：
bool containsElement = set.contains(20); // 此时 containsElement 的值为 true

//通过 foreach 循环遍历集合中的元素
foreach(int element, set) {
    // 处理元素
}

set.remove(20); // 现在从集合中移除了元素 20
// 现在集合中剩余两个元素，10 和 30

//使用 intersect() 函数求两个集合的交集：
QSet<int> set1 = {10, 20, 30};
QSet<int> set2 = {20, 30, 40};
QSet<int> intersection = set1.intersect(set2); // intersection 中仅包含 20 和 30

//使用 unite() 函数求两个集合的并集：
QSet<int> set1 = {10, 20, 30};
QSet<int> set2 = {20, 30, 40};
QSet<int> unionSet = set1.unite(set2); // unionSet 中包含所有元素即 10、20、30、40

 QMap篇：一个关联数组，将键和值映射在一起。通常实现使用红黑树，它支持插入、查找和删除操作的顺序（根据键）保证为O(logN)。

#include <QMap>

QMap<QString, int> myMap; // 创建一个键为 QString 类型，值为 int 类型的 QMap 对象

myMap.insert("apple", 5);    // 向 myMap 中插入一个键值对，键为 "apple"，值为 5
myMap.insert("banana", 10);  // 向 myMap 中插入一个键值对，键为 "banana"，值为 10
myMap.insert("cherry", 15);  // 向 myMap 中插入一个键值对，键为 "cherry"，值为 15

int value1 = myMap.value("apple");   // 获取键为 "apple" 的值，返回值为 5
int value2 = myMap.value("pear");    // 获取键为 "pear" 的值，由于 myMap 中不存在 "pear" 对应的值，返回默认值 0

myMap["banana"] = 12;   // 将键为 "banana" 的值修改为 12

bool contains = myMap.contains("pear");   // 判断 myMap 中是否存在键为 "pear" 的项，返回 false

myMap.remove("cherry");   // 删除键为 "cherry" 的项

QMap<QString, int>::const_iterator it;
for (it = myMap.constBegin(); it != myMap.constEnd(); ++it) {
    QString key = it.key();     // 获取当前项的键
    int value = it.value();     // 获取当前项的值
    qDebug() << key << value;   // 输出每个键值对
}

QHash 篇

QHash<QString, int> myHash; // 创建一个键为 QString 类型，值为 int 类型的 QHash 对象

myHash.insert("apple", 5);    // 向 myHash 中插入一个键值对，键为 "apple"，值为 5
myHash.insert("banana", 10);  // 向 myHash 中插入一个键值对，键为 "banana"，值为 10
myHash.insert("cherry", 15);  // 向 myHash 中插入一个键值对，键为 "cherry"，值为 15

int value1 = myHash.value("apple");   // 获取键为 "apple" 的值，返回值为 5
int value2 = myHash.value("pear");    // 获取键为 "pear" 的值，由于 myHash 中不存在 "pear" 对应的值，返回默认值 0

myHash["banana"] = 12;   // 将键为 "banana" 的值修改为 12

bool contains = myHash.contains("pear");   // 判断 myHash 中是否存在键为 "pear" 的项，返回 false

myHash.remove("cherry");   // 删除键为 "cherry" 的项

QHash<QString, int>::const_iterator it;
for (it = myHash.constBegin(); it != myHash.constEnd(); ++it) {
    QString key = it.key();     // 获取当前项的键
    int value = it.value();     // 获取当前项的值
    qDebug() << key << value;   // 输出每个键值对
}