这是本节的多页打印视图。点击此处打印.

stl

迭代器相关
容器相关
stl 算法分析
函数对象

描述

STL（Standard Template Library，标准模板库）是 C++ 标准库的重要组成部分，提供了高效且通用的数据结构和算法。

STL 的核心要素主要包括以下几个方面

容器(Containers): 容器是用于存储和组织数据的数据结构。STL 提供了多种类型的容器，每种容器都有其特定的特性和使用场景。
迭代器(Iterators): 迭代器是用于遍历容器中元素的指针或指针类似的对象。STL 提供了多种类型的迭代器，以适应不同容器的需求。
算法(Algorithms): 算法是用于处理容器中数据的函数模板。STL 提供了大量的算法，涵盖了排序、查找、修改、数值计算等多种操作。
函数对象(Function Objects): 函数对象是重载了函数调用运算符 operator() 的对象，可以像普通函数一样调用。STL 提供了一些预定义的函数对象，用于算法中的比较和操作
适配器(Adapters): 适配器用于改变现有容器的行为，使其符合特定的需求。

迭代器相关

Monday, November 01, 2021

描述

容器相关

Monday, November 01, 2021

描述

stl 提供的数据类型

序列容器

序列容器存储元素的顺序集合，支持随机访问或顺序访问。

vector: array

特点: 动态数组, 支持随机访问, 末尾插入和删除效率高
使用场景：适用于需要频繁随机访问和在末尾进行插入和删除操作的场景。

  #include <vector>
  #include <iostream>

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

list:

特点: 双向链表，支持高效的插入和删除操作，但不支持随机访问。

使用场景：适用于需要频繁在任意位置进行插入和删除操作的场景

#include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.push_front(0); // 在头部添加元素
    lst.push_back(6);  // 在末尾添加元素
    for (int val : lst) {
        std::cout << val << " "; // 输出: 0 1 2 3 4 5 6
    }
    return 0;
}

deque:

特点：双端队列，支持高效的前端和后端插入和删除操作，也支持随机访问

使用场景：适用于需要在两端进行插入和删除操作的场景。

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq = {1, 2, 3, 4, 5};
    deq.push_front(0); // 在头部添加元素
    deq.push_back(6);  // 在末尾添加元素
    for (int val : deq) {
        std::cout << val << " "; // 输出: 0 1 2 3 4 5 6
    }
    return 0;
}

关联容器

关联容器存储键值对，支持高效的查找操作

set:

特点：有序集合，不允许重复元素，支持高效的查找、插入和删除操作。

使用场景：适用于需要唯一键值且有序存储的场景。

#include <set>
#include <iostream>

int main() {
    std::set<int> s = {5, 3, 1, 4, 2};
    s.insert(6); // 插入元素
    for (int val : s) {
        std::cout << val << " "; // 输出: 1 2 3 4 5 6
    }
    return 0;
}

map:

特点：有序键值对集合，不允许重复键，支持高效的查找、插入和删除操作。
使用场景：适用于需要唯一键值且有序存储键值对的场景。

  #include <map>
  #include <iostream>

  int main() {
      std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};
      m["date"] = 4; // 插入键值对
      for (const auto& pair : m) {
          std::cout << pair.first << ": " << pair.second << std::endl;
      }
      return 0;
  }

multiset: -特点：有序集合，允许重复元素，支持高效的查找、插入和删除操作。

使用场景：适用于需要唯一键值但允许重复且有序存储的场景。

  #include <set>
  #include <iostream>

  int main() {
      std::multiset<int> ms = {5, 3, 1, 4, 2, 3};
      ms.insert(6); // 插入元素
      for (int val : ms) {
          std::cout << val << " "; // 输出: 1 2 3 3 4 5 6
      }
      return 0;
  }

multimap:

特点：有序键值对集合，允许重复键，支持高效的查找、插入和删除操作。
使用场景：适用于需要唯一键值但允许重复且有序存储键值对的场景

  #include <map>
  #include <iostream>

  int main() {
      std::multimap<std::string, int> mm = {{"apple", 1}, {"banana", 2}, {"apple", 3}};
      mm.insert({"cherry", 4}); // 插入键值对
      for (const auto& pair : mm) {
          std::cout << pair.first << ": " << pair.second << std::endl;
      }
      return 0;
  }

无序容器

无序容器存储键值对，支持高效的查找操作，但不保证元素的顺序。

unordered_set:

特点：无序集合，不允许重复元素，支持高效的查找、插入和删除操作。
使用场景：适用于需要唯一键值且不需要有序存储的场景。

  #include <unordered_set>
  #include <iostream>

  int main() {
      std::unordered_set<int> us = {5, 3, 1, 4, 2};
      us.insert(6); // 插入元素
      for (int val : us) {
          std::cout << val << " "; // 输出顺序不确定
      }
      return 0;
  }

unordered_map

特点：无序键值对集合，不允许重复键，支持高效的查找、插入和删除操作。
使用场景：适用于需要唯一键值且不需要有序存储键值对的场景。

  #include <unordered_map>
  #include <iostream>

  int main() {
      std::unordered_map<std::string, int> um = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};
      um["date"] = 4; // 插入键值对
      for (const auto& pair : um) {
          std::cout << pair.first << ": " << pair.second << std::endl;
      }
      return 0;
  }

unordered_multiset

特点：无序集合，允许重复元素，支持高效的查找、插入和删除操作。

使用场景：适用于需要唯一键值但允许重复且不需要有序存储的场景

#include <unordered_set>
#include <iostream>

int main() {
    std::unordered_multiset<int> ums = {5, 3, 1, 4, 2, 3};
    ums.insert(6); // 插入元素
    for (int val : ums) {
        std::cout << val << " "; // 输出顺序不确定
    }
    return 0;
}

unordered_multimap

特点：无序键值对集合，允许重复键，支持高效的查找、插入和删除操作。
使用场景：适用于需要唯一键值但允许重复且不需要有序存储键值对的场景。

  #include <unordered_map>
  #include <iostream>

  int main() {
      std::unordered_multimap<std::string, int> umm = {{"apple", 1}, {"banana", 2}, {"apple", 3}};
      umm.insert({"cherry", 4}); // 插入键值对
      for (const auto& pair : umm) {
          std::cout << pair.first << ": " << pair.second << std::endl;
      }
      return 0;
  }

容器适配器

容器适配器基于其他容器构建，提供特定的功能。

stack

特点：后进先出（LIFO）的数据结构，基于 deque、vector 或 list 实现。
使用场景：适用于需要栈操作的场景。

  #include <stack>
  #include <iostream>

  int main() {
      std::stack<int> stk;
      stk.push(1);
      stk.push(2);
      stk.push(3);
      std::cout << "Top element: " << stk.top() << std::endl; // 输出: Top element: 3
      stk.pop();
      std::cout << "Top element after pop: " << stk.top() << std::endl; // 输出: Top element after pop: 2
      return 0;
  }

queue

特点：先进先出（FIFO）的数据结构，基于 deque 或 list 实现。
使用场景：适用于需要队列操作的场景。

  #include <queue>
  #include <iostream>

  int main() {
      std::queue<int> q;
      q.push(1);
      q.push(2);
      q.push(3);
      std::cout << "Front element: " << q.front() << std::endl; // 输出: Front element: 1
      q.pop();
      std::cout << "Front element after pop: " << q.front() << std::endl; // 输出: Front element after pop: 2
      return 0;
  }

priority_queue

特点：最大堆（默认）或最小堆的数据结构，基于 vector 实现。
使用场景：适用于需要优先级队列操作的场景。

  #include <queue>
  #include <iostream>

  int main() {
      std::priority_queue<int> pq;
      pq.push(3);
      pq.push(1);
      pq.push(2);
      std::cout << "Top element: " << pq.top() << std::endl; // 输出: Top element: 3
      pq.pop();
      std::cout << "Top element after pop: " << pq.top() << std::endl; // 输出: Top element after pop: 2
      return 0;
  }

stl 算法分析

Monday, June 29, 2020

描述

函数对象

Saturday, October 06, 2018

描述

比较函数对象: less, greater, equal_to, not_equal_to 等。
算术函数对象: plus, minus, multiplies, divides, modulus, negate 等。
逻辑函数对象: logical_and, logical_or, logical_not 等