首页手记 STL容器入门教程：轻松掌握C++标准模板库中的容器

STL容器入门教程：轻松掌握C++标准模板库中的容器

标签：

C++ 数据结构容器

概述

STL容器是C++标准库的一部分，用于高效存储和管理数据。它们提供了多种操作，如插入、删除和查找等，并支持泛型编程和算法库。STL容器具有自动内存管理和一致的接口，使得编程更加便捷。

STL容器简介

什么是STL容器

STL（Standard Template Library）是C++标准库的一部分，它提供了一系列通用的、可重用的数据结构和算法。这些数据结构通常被称为容器，它们用于存储、组织和操作数据。通过引入STL容器，编写高效、可维护的代码变得更加容易。

STL容器的作用与特点

STL容器的主要作用是可以高效地存储和管理数据。它们提供了多种通用操作，包括插入、删除、查找和遍历等。STL容器具有以下特点：

泛型编程：STL容器使用模板技术实现了泛型编程，这意味着你可以使用不同的数据类型来操作容器，而不需要为每种类型编写不同的代码。
算法支持：STL容器通常与STL算法库一起使用，提供了丰富的操作方法，如排序、搜索、变换等。
内存管理：容器自动管理内存，减少了内存泄漏的风险。
接口一致：所有的STL容器都遵循一致的接口规则，这使得学习和使用这些容器变得更加容易。

如何在项目中引入STL容器

在C++项目中，STL容器是标准库的一部分，因此不需要额外安装或引入。你只需要在代码中包含相应的头文件即可开始使用STL容器。例如，要使用vector容器，你需要包含<vector>头文件：

#include <vector>

然后，你可以在代码中声明并使用vector对象：

int main() {
    std::vector<int> numbers; // 创建一个vector容器
    numbers.push_back(1);    // 插入元素
    numbers.push_back(2);
    numbers.push_back(3);
    return 0;
}

常用STL容器类型

向量(vector)

向量容器是动态数组的实现，它允许添加和删除元素，同时自动调整其容量。向量支持随机访问，即可以通过索引直接访问任意位置的元素。向量通常用于需要快速随机访问和动态调整大小的情况。

#include <vector>

int main() {
    std::vector<int> vec; // 创建一个空的vector
    vec.push_back(1);     // 向vector中添加元素
    vec.push_back(2);
    vec.push_back(3);
    // 访问元素
    int firstElement = vec[0];
    return 0;
}

链表(list)

链表容器是一种双向链表实现，它允许高效的插入和删除操作，但访问元素的速度较慢。链表通常用于需要频繁插入或删除元素，而不频繁访问元素的情况。

#include <list>

int main() {
    std::list<int> lst; // 创建一个空的list
    lst.push_back(1);   // 向list中添加元素
    lst.push_back(2);
    lst.push_back(3);
    // 访问元素
    auto it = lst.begin(); // 获取迭代器
    int firstElement = *it;
    return 0;
}

双向队列(deque)

双向队列容器允许从两端高效地插入和删除元素，同时提供随机访问。双向队列通常用于需要同时从队列两端操作数据的情况。

#include <deque>

int main() {
    std::deque<int> deq; // 创建一个空的deque
    deq.push_back(1);    // 向deque中添加元素
    deq.push_back(2);
    deq.push_front(0);   // 在前端添加元素
    // 访问元素
    int firstElement = deq[0];
    return 0;
}

集合(set)

集合容器是一个有序元素的集合，不允许重复元素。集合通常用于需要唯一元素存储和高效查找的情况。

#include <set>

int main() {
    std::set<int> st; // 创建一个空的set
    st.insert(1);     // 向set中添加元素
    st.insert(2);
    st.insert(2);     // 重复元素会被忽略
    st.insert(3);
    // 遍历集合
    for (const auto& elem : st) {
        std::cout << elem << " ";
    }
    return 0;
}

映射(map)

映射容器是一个包含键值对的有序集合，其中键是唯一的。映射通常用于需要关联键值对的情况，如实现字典或哈希表。

#include <map>

int main() {
    std::map<int, std::string> mp; // 创建一个空的map
    mp[1] = "one";                 // 添加键值对
    mp[2] = "two";
    mp[3] = "three";
    // 访问元素
    std::string value = mp[1];
    return 0;
}

STL容器的基本操作

创建与初始化容器

创建和初始化容器是使用STL容器的第一步。你可以使用多种方式来初始化容器，例如使用构造函数、初始化列表、赋值等。

#include <vector>
#include <list>

int main() {
    // 使用构造函数创建容器
    std::vector<int> vec1;            // 创建一个空vector
    std::list<int> lst1(3, 1);        // 创建一个包含三个1的list

    // 使用初始化列表创建容器
    std::vector<int> vec2 = {1, 2, 3}; // 使用初始化列表创建vector
    std::list<int> lst2 = {4, 5, 6};   // 使用初始化列表创建list

    // 使用赋值操作创建容器
    std::vector<int> vec3 = vec2;      // 使用已有的vector初始化新vector
    return 0;
}

插入与删除元素

插入和删除元素是容器的基本操作，不同的容器有不同的插入和删除方法。这里以vector和list为例：

#include <vector>
#include <list>

int main() {
    std::vector<int> vec;
    std::list<int> lst;

    // 插入元素
    vec.push_back(1); // 向vector中插入元素
    vec.push_back(2);
    lst.push_back(1); // 向list中插入元素
    lst.push_back(2);

    // 删除元素
    vec.pop_back();   // 删除vector的最后一个元素
    lst.pop_back();   // 删除list的最后一个元素

    return 0;
}

访问元素

访问容器中的元素可以通过索引或迭代器。索引访问通常用于支持随机访问的容器，如vector和deque；而迭代器访问则适用于所有容器。

#include <vector>
#include <list>

int main() {
    std::vector<int> vec = {1, 2, 3};
    std::list<int> lst = {4, 5, 6};

    // 索引访问
    int elementVec = vec[1]; // 访问vector中的第二个元素
    auto it = lst.begin();   // 获取list的迭代器
    int elementLst = *it;    // 访问list中的第一个元素

    return 0;
}

遍历容器中的元素

遍历容器中的元素可以通过迭代器或范围for循环。迭代器遍历适用于所有容器，而范围for循环则需要C++11或更高版本的支持。

#include <vector>
#include <list>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3};
    std::list<int> lst = {4, 5, 6};

    // 使用迭代器遍历vector
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用范围for循环遍历list
    for (const auto& elem : lst) {
        std::cout << elem << " ";
    }
    return 0;
}

STL容器的迭代器

什么是迭代器

迭代器是C++中用于遍历容器的指针替代品。迭代器提供了类似指针的操作，但具有泛型编程的特性，使得它可以在不同类型的容器中使用。迭代器允许你访问、修改容器中的元素，并支持基本的指针操作，如解引用、自增和自减等。

迭代器的使用方法

迭代器可以用于各种容器操作，如插入、删除、访问和遍历等。以下是一些常用的迭代器操作：

#include <vector>
#include <list>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3};
    std::list<int> lst = {4, 5, 6};

    // 使用迭代器插入元素
    vec.insert(vec.begin() + 1, 10); // 在第一个元素后面插入10
    lst.insert(lst.begin() + 1, 10); // 在第一个元素后面插入10

    // 使用迭代器删除元素
    vec.erase(vec.begin() + 1);      // 删除第二个元素
    lst.erase(lst.begin() + 1);      // 删除第二个元素

    // 使用迭代器访问元素
    auto itVec = vec.begin();        // 获取迭代器
    int firstElementVec = *itVec;    // 解引用迭代器

    auto itLst = lst.begin();        // 获取迭代器
    int firstElementLst = *itLst;    // 解引用迭代器

    // 使用迭代器遍历容器
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

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

迭代器的类型与选择

迭代器类型分为五种：

输入迭代器：只能向前遍历，不能用于修改元素。
输出迭代器：只能向前遍历，只能用于修改元素。
前向迭代器：可以向前和向后遍历，但不能随机访问。
双向迭代器：可以向前和向后遍历，可以随机访问。
随机访问迭代器：可以向前和向后遍历，可以随机访问，支持算术运算。

选择合适的迭代器类型取决于你的具体需求。例如，vector和deque使用随机访问迭代器，而list使用双向迭代器。

#include <vector>
#include <list>

int main() {
    std::vector<int> vec = {1, 2, 3};
    std::list<int> lst = {4, 5, 6};

    // 使用随机访问迭代器
    auto vecIt = vec.begin();
    vecIt += 1; // 支持算术运算

    // 使用双向迭代器
    auto lstIt = lst.begin();
    lstIt++;    // 支持前向遍历

    return 0;
}

容器的比较与排序

容器元素的比较

比较容器中的元素可以通过自定义比较函数或使用默认的比较规则。默认的比较规则通常使用<操作符，但你可以提供自定义的比较函数来满足特定需求。

#include <vector>
#include <algorithm>
#include <iostream>

bool customCompare(int a, int b) {
    return a > b; // 自定义比较函数
}

int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5};

    // 使用默认比较规则
    std::sort(vec.begin(), vec.end());

    // 使用自定义比较规则
    std::sort(vec.begin(), vec.end(), customCompare);

    // 输出排序后的vector
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    return 0;
}

容器的排序操作

STL提供了sort函数来对容器中的元素进行排序。sort函数默认使用元素的<操作符进行比较，但也可以通过传递自定义的比较函数或函数对象来实现更复杂的排序逻辑。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5};

    // 使用默认比较规则排序
    std::sort(vec.begin(), vec.end());

    // 输出排序后的vector
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 使用自定义比较规则排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });

    // 输出排序后的vector
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    return 0;
}

自定义排序规则

自定义排序规则通常通过传递一个函数对象或lambda表达式来实现。这些函数对象或lambda表达式需要定义元素比较的逻辑。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<std::string> vec = {"banana", "apple", "orange", "pear"};

    // 使用自定义比较规则排序
    std::sort(vec.begin(), vec.end(), [](const std::string& a, const std::string& b) {
        return a.size() < b.size(); // 按字符串长度排序
    });

    // 输出排序后的vector
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    return 0;
}

常见问题与解决方案

常见错误与解决方法

在使用STL容器时，常见的错误包括内存泄漏、访问越界、使用无效迭代器等。以下是一些常见的问题及其解决方法：

内存泄漏：确保容器和其内部元素的生命周期是正确的，特别是在使用动态内存分配时。
访问越界：确保在访问容器元素时不会超出容器的范围。可以使用size()或end()方法来检查边界。
使用无效迭代器：避免使用已经失效的迭代器，例如在容器被修改后仍然使用迭代器。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3};

    // 访问越界
    try {
        int invalidElement = vec.at(3); // 使用at方法来防止越界
    } catch (const std::out_of_range& e) {
        std::cout << "访问越界: " << e.what() << std::endl;
    }

    // 使用无效迭代器
    auto it = vec.begin();
    vec.pop_back(); // 移除元素
    // 使用已经失效的迭代器
    int invalidElement = *it;

    return 0;
}

性能优化建议

性能优化是提高程序效率的重要手段。以下是一些提高STL容器性能的建议：

选择合适的容器：不同的容器有不同的性能特性，选择最合适的容器可以显著提高性能。例如，vector适合频繁插入和删除操作，而list适合频繁插入和删除操作。
避免不必要的拷贝：使用引用和指针可以避免不必要的数据拷贝，从而提高性能。
使用局部变量：局部变量通常比全局变量更快，因为它们存储在栈上，而不是堆上。

#include <vector>
#include <list>
#include <iostream>

int main() {
    // 使用局部变量
    {
        std::vector<int> vec = {1, 2, 3};
        for (const auto& elem : vec) {
            std::cout << elem << " ";
        }
    }

    // 使用全局变量
    std::vector<int> globalVec = {1, 2, 3};
    for (const auto& elem : globalVec) {
        std::cout << elem << " ";
    }
    return 0;
}

常用库函数介绍

STL库提供了许多有用的函数，这些函数可以简化容器的操作并提高代码的可读性。以下是一些常用的库函数：

std::copy：将一个范围内的元素复制到另一个范围。
std::fill：将一个范围内的元素填充为指定值。
std::find：查找指定值在范围内的位置。
std::count：计算指定值在范围内的出现次数。


#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 2, 3, 4, 2};

    // 使用std::copy复制元素
    std::vector<int> copyVec(vec.size());
    std::copy(vec.begin(), vec.end(), copyVec.begin());

    // 使用std::fill填充元素
    std::fill(copyVec.begin(), copyVec.end(), 0);

    // 使用std::find查找元素
    auto it = std::find(copyVec.begin(), copyVec.end(), 2);

    // 使用std::count计算元素出现次数
    int count = std::count(vec.begin(), vec.end(), 2);

    std::cout << "copyVec: ";
    for (const auto& elem : copyVec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    std::cout << "count: " << count << std::endl;

    return 0;
}
``

通过了解和掌握这些常见的库函数，你可以更高效地使用STL容器。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

德玛西亚99

手记
篇

粉丝

92

获赞与收藏

559

关注作者，订阅最新文章

阅读免费教程

数据结构入门教程

7个小节 23686 615

Android Studio 编辑器教程

40个小节 11886 244

后端通用面试教程

41个小节 30936 346

ES6-10 入门教程

61个小节 93882 733

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空