c++入门

STL标准模板库

容器（Containers）

容器是STL的核心组件之一，提供了各种数据结构，如向量、列表、集合、映射等。这些容器提供了不同的操作和特性，可以根据需要选择合适的容器。

以下是一些常用的STL容器：

vector：动态数组，提供快速的随机访问。
list：双向链表，支持快速插入和删除操作。
set：有序集合，存储唯一的元素。
map：有序映射，存储键值对。
stack：堆栈，先进后出（LIFO）的数据结构。
queue：队列，先进先出（FIFO）的数据结构。

vector（动态数组）

#include <vector>
std::vector<T> vec;  // 创建一个空的 vector，元素类型为 T
std::vector<T> vec(n);  // 创建包含 n 个默认初始化的元素的 vector
std::vector<T> vec(n, value);  // 创建包含 n 个初始化为 value 的元素的 vector
std::vector<T> vec(begin, end);  // 创建包含范围 [begin, end) 内的元素的 vector
std::vector<T> vec(other);  // 创建另一个 vector 的副本

常用成员函数

• size()：返回 vector 中的元素数量。
• empty()：检查 vector 是否为空。
• push_back(value)：在 vector 的末尾添加一个元素。
• pop_back()：删除 vector 的最后一个元素。
• front()：访问 vector 的第一个元素。
• back()：访问 vector 的最后一个元素。
• clear()：清空 vector 中的所有元素。
• insert(position, value)：在指定位置插入一个元素。
• erase(position)：删除指定位置的元素。
• erase(begin, end)：删除指定范围内的元素。

遍历动态数组元素

for (int num : vec)
	{
		std::cout << num << std::endl;
	}
	std::cout << std::endl;

list（双向链表）

#include <list>
std::list<T> lst;  // 创建一个空的 list，元素类型为 T
std::list<T> lst(n);  // 创建包含 n 个默认初始化的元素的 list
std::list<T> lst(n, value);  // 创建包含 n 个初始化为 value 的元素的 list
std::list<T> lst(begin, end);  // 创建包含范围 [begin, end) 内的元素的 list
std::list<T> lst(other);  // 创建另一个 list 的副本

常用成员函数

• size()：返回 list 中的元素数量。
• empty()：检查 list 是否为空。
• push_back(value)：在 list 的末尾添加一个元素。
• push_front(value)：在 list 的开头添加一个元素。
• pop_back()：删除 list 的最后一个元素。
• pop_front()：删除 list 的第一个元素。
• front()：访问 list 的第一个元素。
• back()：访问 list 的最后一个元素。
• clear()：清空 list 中的所有元素。
• insert(position, value)：在指定位置插入一个元素。
• erase(position)：删除指定位置的元素。
• erase(begin, end)：删除指定范围内的元素。

map（关联容器）

概述

map 是一个关联容器，它提供了一对一的键值对存储和访问功能。它基于红黑树

实现，具有自动排序的特性，键值对按键进行排序，并且可以快速地进行插入、删除和查找操作。

#include <map>
std::map<Key, T> mp;  // 创建一个空的 map，键类型为 Key，值类型为 T
std::map<Key, T> mp(other);  // 创建另一个 map 的副本

常用成员函数

• size()：返回 map 中的键值对数量。

• empty()：检查 map 是否为空。

• insert({key, value})：插入一个键值对到 map 中。

• erase(key)：删除指定键的键值对。

• clear()：清空 map 中的所有键值对。

• find(key)：查找指定键对应的迭代器。

• begin()：返回指向第一个键值对的迭代器。

• end()：返回指向最后一个键值对之后的迭代器。

遍历map容器的元素

for (const auto& pair : mp) {
        std::cout << pair.first << ": " << pair.second << std::endl;  // 遍历并输出键值对
    }
//const auto是c++里面的一个引用

set（关联容器）

概述

set 是一个关联容器，它存储唯一的元素，且自动按照键进行排序。set 的底层实现基于红黑树，具有快速的插入、删除和查找操作

#include <set>
std::set<T> st;  // 创建一个空的 set，元素类型为 T
std::set<T> st(other);  // 创建另一个 set 的副本

常用成员函数

• size()：返回 set 中的元素数量。
• empty()：检查 set 是否为空。
• insert(value)：向 set 中插入一个元素。
• erase(value)：删除 set 中指定的元素。
• clear()：清空 set 中的所有元素。
• find(value)：查找 set 中是否存在指定的元素。
• begin()：返回指向第一个元素的迭代器。
• end()：返回指向最后一个元素之后的迭代器。

stack（适配器容器）

概述

stack 是一个适配器容器，它提供了栈（先进后出）的行为。stack 内部使用其他容器作为其底层实现，默认情况下使用 deque 作为底层容器。

#include <stack>
std::stack<T> stk;  // 创建一个空的 stack，元素类型为 T

常用成员函数

• size()：返回 stack 中的元素数量。
• empty()：检查 stack 是否为空。
• push(value)：将元素压入 stack。
• pop()：弹出 stack 的顶部元素。
• top()：返回 stack 的顶部元素的引用。

queue（适配器容器）

概述

queue 是一个适配器容器，它提供了队列（先进先出）的行为。queue 内部使用其他容器作为其底层实现，默认情况下使用 deque 作为底层容器。

#include <queue>
std::queue<T> que;  // 创建一个空的 queue，元素类型为 T

常用成员函数

size()：返回 queue 中的元素数量。
empty()：检查 queue 是否为空。
push(value)：将元素加入到 queue 的末尾。
pop()：移除 queue 的首个元素。
front()：返回 queue 的首个元素的引用。
back()：返回 queue 的末尾元素的引用。

STL算法

std::reverse()

template< class BidirIt >
void reverse( BidirIt first, BidirIt last );
first 和 last：定义了容器中要进行反转的元素的范围。这个范围是一个双向迭代器（Bidirectional Iterator），可以在正向和反向方向上进行遍历。

std::replace()

std::replace() 算法用于将容器中的指定值替换为另一个值。

template< class ForwardIt, class T >
void replace( ForwardIt first, ForwardIt last, const T& old_value, const T& new_value );
first 和 last：定义了容器中要进行替换的元素的范围。
old_value：要替换的旧值。
new_value：要替换成的新值。

std::transform()

算法用于对容器中的元素应用一个操作，并将结果存储到另一个容器中

template< class InputIt, class OutputIt, class UnaryOperation >
OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op );
first1 和 last1：定义了输入容器中要应用操作的元素的范围。
d_first：定义了输出容器的起始位置，用于存储操作的结果。
unary_op：要应用的一元操作，可以是函数对象、函数指针或 Lambda 表达式。

std::for_each()

template< class InputIt, class UnaryFunction >
UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );
first 和 last：定义了容器中要应用操作的元素的范围。
f：要应用的操作，可以是函数对象、函数指针或 Lambda 表达式。

std::binary_search()

std::binary_search() 算法用于在已排序的容器中执行二分查找。

template< class ForwardIt, class T >
bool binary_search( ForwardIt first, ForwardIt last, const T& value );
first 和 last：定义了容器中要进行查找的元素的范围。
value：要查找的值。

std::copy()

算法用于将一个容器中的元素复制到另一个容器中。

template< class InputIt, class OutputIt >
OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
first 和 last：定义了要复制的元素的范围。
d_first：定义了目标容器的起始位置，用于存储复制的元素。

std::remove()

算法用于从容器中移除指定值的元素，但并不实际删除这些元素，而是将它们移到容器的末尾，并返回一个指向新的逻辑末尾的迭代器。

template< class ForwardIt, class T >
ForwardIt remove( ForwardIt first, ForwardIt last, const T& value );
first 和 last：定义了要移除元素的范围。
value：指定要移除的值

std::unique()

算法用于移除容器中的连续重复元素，并返回一个指向新的逻辑末尾的迭代器。

template< class ForwardIt >
ForwardIt unique( ForwardIt first, ForwardIt last );
first 和 last：定义了要移除重复元素的范围。

std::min_element()

算法用于在容器中找到最小元素，并返回指向该元素的迭代器。

template< class ForwardIt >
ForwardIt min_element( ForwardIt first, ForwardIt last );
first 和 last：定义了要查找最小元素的范围。

std::max_element()

算法用于在容器中找到最大元素，并返回指向该元素的迭代器。

template< class ForwardIt >
ForwardIt max_element( ForwardIt first, ForwardIt last );
first 和 last：定义了要查找最大元素的范围。