C++ STL入门：解锁现代C++编程的强大工具箱

引言

在现代C++编程中，标准模板库（Standard Template Library，STL）是不可或缺的一部分，它提供了一系列广泛使用的数据结构和算法。对于有其他编程背景但未接触过STL的程序员来说，掌握STL将大大提升编写高效、简洁和强大的C++代码的能力。本文将通过实例和简明的解释，引领读者步入STL的世界。

STL基础

STL是C++的一个强大功能库，它支持泛型编程。STL中的每个组件都是模板化的，这意味着它们可以与任何数据类型一起工作，提供极高的灵活性和代码复用性。STL主要由以下几部分构成：

• 容器：存储数据的通用数据结构，如向量（vector）、列表（list）、映射（map）等。
• 迭代器：提供访问容器中元素的方法，类似于指针。
• 算法：对数据执行操作的函数模板，例如排序和搜索。
• 函数对象：行为类似函数的对象，可以作为算法的某些操作。
• 配接器：修改容器或函数对象接口的工具。

STL的设计目标是高效和可重用，使得程序员可以集中精力解决具体问题，而不是重新发明数据结构和算法。

容器

STL提供了一系列的容器，分为序列容器、关联容器和容器适配器三种，每种容器都支持不同的数据组织和存取方式。

序列容器

• vector：向量是一个动态数组，支持随机访问。它可以在尾部快速插入或删除元素，但在中间或开始插入元素可能较慢。

  #include <vector>
  #include <iostream>
  
  int main() {
      std::vector<int> vec = {1, 2, 3, 4};
      vec.push_back(5); // 在末尾添加元素
      for(int i : vec) {
          std::cout << i << " ";
      }
      // 输出: 1 2 3 4 5
      return 0;
  }
  

• list：列表是一个双向链表，支持在任何位置快速插入和删除元素，但不支持随机访问。

  #include <list>
  #include <iostream>
  
  int main() {
      std::list<int> lst = {1, 2, 3, 4};
      lst.push_front(0); // 在开头添加元素
      for(int i : lst) {
          std::cout << i << " ";
      }
      // 输出: 0 1 2 3 4
      return 0;
  }
  

• deque：双端队列，结合了向量和列表的优点，可以在两端快速插入和删除元素，同时提供随机访问。

  #include <deque>
  #include <iostream>
  
  int main() {
      std::deque<int> deq = {2, 3, 4};
      deq.push_front(1); // 在前端添加元素
      deq.push_back(5);  // 在后端添加元素
      for(int i : deq) {
          std::cout << i << " ";
      }
      // 输出: 1 2 3 4 5
      return 0;
  }
  

关联容器

• set：集合是一个存储唯一元素的容器，内部自动根据元素的值进行排序。

  #include <set>
  #include <iostream>
  
  int main() {
      std::set<int> s = {3, 1, 4, 1, 2};
      s.insert(5); // 尝试添加元素
      for(int i : s) {
          std::cout << i << " ";
      }
      // 输出: 1 2 3 4 5
      return 0;
  }
  

• map：映射是一种关联数组，存储键值对，其中每个键都是唯一的，内部根据键自动排序。

  #include <map>
  #include <iostream>
  
  int main() {
      std::map<char, int> m;
      m['a'] = 1;
      m['b'] = 2;
      m['c'] = 3;
      for(auto& pair : m) {
          std::cout << pair.first << ": " << pair.second << "\n";
      }
      // 输出: a: 1 b: 2 c: 3
      return 0;
  }
  

容器适配器

• stack：栈提供了在一端插入和删除元素的LIFO（后进先出）数据结构。

  #include <stack>
  #include <iostream>
  
  int main() {
      std::stack<int> stack;
      stack.push(1);
      stack.push(2);
      stack.push(3);
      while (!stack.empty()) {
          std::cout << stack.top() << " ";
          stack.pop();
      }
      // 输出: 3 2 1
      return 0;
  }
  

• queue：队列提供了在一端插入而在另一端删除元素的FIFO（先进先出）数据结构。

  #include <queue>
  #include <iostream>
  
  int main() {
      std::queue<int> queue;
      queue.push(1);
      queue.push(2);
      queue.push(3);
      while (!queue.empty()) {
          std::cout << queue.front() << " ";
          queue.pop();
      }
      // 输出: 1 2 3
      return 0;
  }
  

容器是STL中最基本的组成部分，为数据的存储和访问提供了强大支持。

算法

STL的算法库提供了一系列广泛使用的算法，如排序、搜索、变换和计算操作。这些算法通常作用于容器，通过迭代器与容器解耦，使得相同的算法可以应用于不同类型的容器。

排序和搜索

• sort：std::sort函数可以对容器中的元素进行排序。它需要两个迭代器作为参数，指定要排序的元素的范围。

  #include <algorithm>
  #include <vector>
  #include <iostream>
  
  int main() {
      std::vector<int> v = {4, 2, 5, 1, 3};
      std::sort(v.begin(), v.end());
      for (int i : v) {
          std::cout << i << " ";
      }
      // 输出: 1 2 3 4 5
      return 0;
  }
  

• find：std::find函数用于搜索容器中的元素，返回一个指向找到的元素的迭代器，如果未找到，则返回指向容器末尾的迭代器。

  #include <algorithm>
  #include <vector>
  #include <iostream>
  
  int main() {
      std::vector<int> v = {1, 2, 3, 4, 5};
      auto it = std::find(v.begin(), v.end(), 3);
      if (it != v.end()) {
          std::cout << "Found " << *it << std::endl;
      } else {
          std::cout << "Not found" << std::endl;
      }
      // 输出: Found 3
      return 0;
  }
  

变换和操作

• transform：std::transform函数可以将指定操作应用于容器中的每个元素，并将结果存储在另一个容器中。

  #include <algorithm>
  #include <vector>
  #include <iostream>
  
  int main() {
      std::vector<int> v = {1, 2, 3, 4, 5};
      std::vector<int> v2(v.size());
      std::transform(v.begin(), v.end(), v2.begin(), [](int val) { return val * val; });
      for (int i : v2) {
          std::cout << i << " ";
      }
      // 输出: 1 4 9 16 25
      return 0;
  }
  

• accumulate：std::accumulate函数用于计算容器中元素的总和，位于<numeric>头文件中。

  #include <numeric>
  #include <vector>
  #include <iostream>
  
  int main() {
      std::vector<int> v = {1, 2, 3, 4, 5};
      int sum = std::accumulate(v.begin(), v.end(), 0);
      std::cout << "Sum: " << sum << std::endl;
      // 输出: Sum: 15
      return 0;
  }
  

STL算法的优势在于它们的通用性和效率。通过将操作抽象化，算法可以应用于几乎所有容器类型，而无需关心容器的具体实现细节。下一节将介绍迭代器，它是容器和算法之间沟通的桥梁。

迭代器

迭代器是访问容器中元素的对象，它提供了一种方法来顺序访问容器中的元素，而不需要了解容器的内部结构。迭代器是STL中的核心概念之一，连接了容器与算法。

迭代器的分类

• 输入迭代器：只能读取序列中的元素一次，不能写入。
• 输出迭代器：只能写入序列中的元素一次，不能读取。
• 前向迭代器：可以多次读写同一个元素，并且能向前移动到下一个元素。
• 双向迭代器：除了具有前向迭代器的所有功能外，还可以向后移动。
• 随机访问迭代器：可以直接访问任何元素，支持迭代器之间的算术运算。

示例：使用迭代器遍历vector

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

通过使用迭代器，算法可以在不知道容器具体实现细节的情况下，操作容器中的数据。这种解耦使得STL具有极高的灵活性和复用性。

实战示例

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

int main() {
    // 创建一个vector容器存储整数
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用算法transform将每个数字平方
    std::transform(numbers.begin(), numbers.end(), numbers.begin(), [](int x) { return x * x; });

    // 使用算法accumulate计算平方后的总和
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

    // 打印结果
    std::cout << "Sum of squares: " << sum << std::endl;
    // 输出: Sum of squares: 55

    return 0;
}

结语

学习使用STL可以更加轻松地处理复杂的数据结构和算法问题。本文旨在针对有编程基础但未接触过STL的程序员快速入门，开启在C++领域的探索之旅。