C++STL速查手册

本文参考cppreference，整理了一些常用的STL容器及其内置函数与算法，方便查用。

C++STL速查手册

  • 什么是STL？
  • STL模板

什么是STL？

在这里插入图片描述

在C++中，STL 是指标准模板库（Standard Template Library）。STL 是 C++ 标准库的一部分，提供了一组通用的模板类和函数，用于实现多种常见的数据结构和算法。STL 的设计目标是提供高效、灵活、可复用的组件，使得程序员能够更加方便地编写高质量的代码。

STL 由以下几个主要部分组成：

  1. 容器（Containers）： 容器是用于存储数据的数据结构，STL 提供了多种容器，包括向量（vector）、链表（list）、双端队列（deque）、队列（queue）、栈（stack）、集合（set）、映射（map）等。这些容器提供了不同的特性和适用场景。

  2. 迭代器（Iterators）： 迭代器是用于访问容器元素的抽象概念，它类似于指针，提供了一种统一的方式来遍历容器中的元素。STL 容器通常可以使用迭代器来进行遍历和操作。

  3. 算法（Algorithms）： STL 提供了大量的通用算法，包括排序、查找、变换、合并等。这些算法能够在各种容器上工作，使得开发人员无需自己实现这些基本的算法，从而提高了代码的可重用性和可读性。

  4. 函数对象（Functors）： 函数对象是可以像函数一样调用的对象。STL 中的函数对象通常用于实现算法的比较和操作。

  5. 配接器（Adapters）： 配接器是一种用于修改或适应容器、迭代器或函数对象的组件。STL 提供了各种配接器，例如栈和队列的适配器，以及迭代器的适配器等。

STL模板

#include <vector>

vector容器的构造函数
vector<T> v; //采用模板类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

vector容器的赋值操作
assign(const_iterator start, const_iterator end); //将[start, end)区间中的数据拷贝赋值给本身。
assign(int n, const T& elem); //将n个elem拷贝赋值给本身。
vector& operator=(const vector  &vec); //重载等号操作符

vector容器的大小操作
v.empty(); //判断容器是否为空
v.size(); //返回容器中元素的个数
v.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
v.resize(int num, const T& elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

vector容器的插入和删除操作
v.push_back(elem); //在容器尾部加入一个元素
v.pop_back(); //删除容器中最后一个元素
v.insert(const_iterator pos, const T& elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
v.insert(const_iterator pos, int count, const T& elem); //在pos位置插入count个elem数据，无返回值。
v.erase(const_iterator pos); //删除pos位置的数据，返回下一个数据的位置。
v.erase(const_iterator start, const_iterator end); //删除[start, end)区间的数据，返回下一个数据的位置。
v.clear(); //移除容器的所有数据



vector容器的数据存取
v.at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
v[idx]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
v.front(); //返回容器中第一个数据元素
v.back(); //返回容器中最后一个数据元素

vector互换
v.swap(v1); // 将v与v1的元素互换

vector的预留空间
v.reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问。

vector的反转操作
reverse(iterator start, iterator end); //将[start, end)区间中的数据反转

vector的排序
sort(iterator start, iterator end); //对[start, end)区间中的数据进行排序
sort(iterator start, iterator end, _Pred); //对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。
sort()成员函数使用的是快速排序算法。

vector的迭代器
v.begin(); //返回容器中第一个数据的迭代器。
v.end(); //返回容器中最后一个数据之后的迭代器。
v.rbegin(); //返回容器中倒数第一个元素的迭代器。
v.rend(); //返回容器中倒数最后一个元素的后面的迭代器。
v.cbegin(); //返回容器中第一个数据的const迭代器。
v.cend(); //返回容器中最后一个数据之后的const迭代器。
v.crbegin(); //返回容器中倒数第一个元素的const迭代器。
v.crend(); //返回容器中倒数最后一个元素的后面的const迭代器。



#include <deque>

deque容器的构造函数
deque() deq; //默认构造函数
deque(int n, value); //构造函数将n个value拷贝给本身。
deque(const deque &deq); //拷贝构造函数

deque容器的赋值操作
deq.assign(const_iterator start, const_iterator end); //将[start, end)区间中的数据拷贝赋值给本身。
deq.assign(int n, const T& val); //将n个val拷贝赋值给本身。
deq.deque& operator=(const deque &deq); //重载等号操作符

deque容器的大小操作
deq.empty(); //判断容器是否为空
deq.size(); //返回容器中元素的个数
deq.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
deq.resize(int num, const T& val); //重新指定容器的长度为num，若容器变长，则以val值填充新位置。
deq.shrink_to_fit(); //请求移除deque中未使用的容量

deque容器的插入和删除操作
deq.push_back(elem); //在容器尾部添加一个数据
deq.push_front(elem); //在容器头部插入一个数据
deq.pop_back(); //删除容器最后一个数据
deq.pop_front(); //删除容器第一个数据
deq.insert(const_iterator it, const T& val); //在it位置插入一个val的拷贝，返回新数据的位置。
deq.insert(const_iterator it, int count, const T& val); //在it位置插入count个val数据，无返回值。
deq.insert(const_iterator it, const_iterator first, const_iterator last); //在it位置插入[first, last)区间的数据，无返回值。
deq.erase(const_iterator it); //删除it位置的数据，返回下一个数据的位置。
deq.erase(const_iterator first, const_iterator last); //删除[first, last)区间的数据，返回下一个数据的位置。
deq.clear(); //清空容器的所有数据


deque容器的数据存取
deq.at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
deq[idx]; //返回索引idx所指的数据，如果idx越界，直接出错。
deq.front(); //返回第一个数据。
deq.back(); //返回最后一个数据 



deque容器的迭代器
deq.begin(); //返回指向第一个数据的迭代器。
deq.end(); //返回指向最后一个数据的下一个迭代器。
deq.rbegin(); //返回指向最后一个数据的迭代器。
deq.rend(); //返回指向第一个数据的前一个迭代器。
deq.cbegin(); //返回指向第一个数据的const迭代器。
deq.cend(); //返回指向最后一个数据的下一个const迭代器。
deq.crbegin(); //返回指向最后一个数据的const迭代器。
deq.crend(); //返回指向第一个数据的前一个const迭代器。



deque容器的互换
deq.swap(deque& other); // 将deq与other的元素互换

deque容器的排序
std::sort(iterator start, iterator end); //对[start, end)区间中的数据进行排序
std::sort(iterator start, iterator end, _Pred); //对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。

list容器的构造函数
list<T> lst; //默认构造函数
list(int n, const T& val = T()); //构造函数将n个val拷贝给本身。
list(InputIterator first, InputIterator last); //构造函数将区间[first, last)中的数据拷贝给本身。
list(const list &lst); //拷贝构造函数

list容器的赋值操作
assign(InputIterator first, InputIterator last); //将区间[first, last)中的数据拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符
lst.swap(list &lst); // 将lst与lst的元素互换


list容器的大小操作
lst.empty(); //判断容器是否为空
lst.size(); //返回容器中元素的个数
lst.resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
lst.resize(int num, const T& val); //重新指定容器的长度为num，若容器变长，则以val值填充新位置。
lst.clear(); //清空所有数据

list容器的数据存取
lst.front(); //返回第一个数据。
lst.back(); //返回最后一个数据

list容器的插入和删除操作
lst.push_back(); //在容器尾部加入一个数据
lst.pop_back(); //删除容器中最后一个数据
lst.push_front(); //在容器开头插入一个数据
lst.pop_front(); //从容器开头移除第一个数据
lst.insert(iterator position, int n, const T& val); //在position位置插入n个val数据，返回指向第一个插入数据的迭代器。
lst.insert(iterator position, const T& val); //在position位置插入val数据，返回指向插入数据的迭代器。
lst.insert(iterator position, InputIterator first, InputIterator last); //在position位置插入区间[first, last)中的数据，返回指向第一个插入数据的迭代器。
lst.erase(iterator position); //删除position位置的数据，返回下一个数据的迭代器。
lst.erase(iterator first, iterator last); //删除区间[first, last)中的数据，返回指向被删除数据之后的迭代器。
lst.remove(val); //删除容器中所有与val值匹配的元素。
lst.remove_if(_Pred); //删除容器中满足条件_Pred的元素。
lst.unique(); //删除容器中相邻的重复元素。

list容器的反转和排序
lst.reverse(); //反转链表
lst.sort(); //链表排序



#include <set>

set容器的构造函数
set<T> st; //默认构造函数
set(const set &st); //拷贝构造函数

multiset容器的构造函数
multiset<T> mst; //默认构造函数
multiset(const multiset &mst); //拷贝构造函数

set容器的赋值操作
set& operator=(const set &st); //重载等号操作符

multiset容器的赋值操作
multiset& operator=(const multiset &mst); //重载等号操作符

set容器的大小操作
st.empty(); //判断容器是否为空
st.size(); //返回容器中元素的个数
st.max_size(); //返回容器能容纳元素的最大个数

multiset容器的大小操作
mst.empty(); //判断容器是否为空
mst.size(); //返回容器中元素的个数
mst.max_size(); //返回容器能容纳元素的最大个数

set容器的插入和删除操作
st.insert(const value_type& val); //在容器中插入元素
st.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
st.erase(const_iterator position); //删除position迭代器所指的元素
st.erase(const value_type& val); //删除容器中值为val的元素
st.erase(first, last); //删除区间[first, last)中的所有元素
st.clear(); //清空所有元素

multiset容器的插入和删除操作
mst.insert(const value_type& val); //在容器中插入元素
mst.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mst.erase(const_iterator position); //删除position迭代器所指的元素
mst.erase(const value_type& val); //删除容器中值为val的元素
mst.erase(first, last); //删除区间[first, last)中的所有元素
mst.clear(); //清空所有元素

set容器的查找操作
st.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
st.count(const value_type& val); //返回容器中值为val的元素个数
st.lower_bound(const value_type& val); //返回第一个>=val元素的迭代器
st.upper_bound(const value_type& val); //返回第一个>val元素的迭代器
st.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

multiset容器的查找操作
mst.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
mst.count(const value_type& val); //返回容器中值为val的元素个数
mst.lower_bound(const value_type& val); //返回第一个>=val元素的迭代器
mst.upper_bound(const value_type& val); //返回第一个>val元素的迭代器
mst.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

set容器的迭代器
st.begin(); //返回指向第一个元素的迭代器
st.end(); //返回末尾的迭代器
st.rbegin(); //返回指向最后一个元素的迭代器
st.rend(); //返回指向第一个元素的迭代器
st.cbegin(); //返回指向第一个元素的const迭代器
st.cend(); //返回末尾的const迭代器
st.crbegin(); //返回指向最后一个元素的const迭代器
st.crend(); //返回指向第一个元素的const迭代器

multiset容器的迭代器
mst.begin(); //返回指向第一个元素的迭代器
mst.end(); //返回末尾的迭代器
mst.rbegin(); //返回指向最后一个元素的迭代器
mst.rend(); //返回指向第一个元素的迭代器
mst.cbegin(); //返回指向第一个元素的const迭代器
mst.cend(); //返回末尾的const迭代器
mst.crbegin(); //返回指向最后一个元素的const迭代器
mst.crend(); //返回指向第一个元素的const迭代器

set容器的互换
st.swap(set &st); // 将st与st的元素互换

multiset容器的互换
mst.swap(multiset &mst); // 将mst与mst的元素互换


#include <unordered_set>

unordered_set容器的构造函数
unordered_set<T> ust; //默认构造函数
unordered_set(const unordered_set &ust); //拷贝构造函数

unordered_multiset容器的构造函数
unordered_multiset<T> umst; //默认构造函数
unordered_multiset(const unordered_multiset &umst); //拷贝构造函数


unordered_set容器的赋值操作
unordered_set& operator=(const unordered_set &ust); //重载等号操作符

unordered_multiset容器的赋值操作
unordered_multiset& operator=(const unordered_multiset &umst); //重载等号操作符

unordered_set容器的大小操作
ust.empty(); //判断容器是否为空
ust.size(); //返回容器中元素的个数
ust.max_size(); //返回容器能容纳元素的最大个数

unordered_multiset容器的大小操作
umst.empty(); //判断容器是否为空
umst.size(); //返回容器中元素的个数
umst.max_size(); //返回容器能容纳元素的最大个数

unordered_set容器的插入和删除操作
ust.insert(const value_type& val); //在容器中插入元素
ust.erase(const value_type& val); //删除容器中值为val的元素
ust.erase(const_iterator position); //删除position迭代器所指的元素
ust.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
ust.clear(); //清空所有元素

unordered_multiset容器的插入和删除操作
umst.insert(const value_type& val); //在容器中插入元素
umst.erase(const value_type& val); //删除容器中值为val的元素
umst.erase(const_iterator position); //删除position迭代器所指的元素
umst.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
umst.clear(); //清空所有元素

unordered_set容器的查找操作
ust.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
ust.count(const value_type& val); //返回容器中值为val的元素个数
ust.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

unordered_multiset容器的查找操作
umst.find( const value_type& val); //查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
umst.count(const value_type& val); //返回容器中值为val的元素个数
umst.equal_range(const value_type& val); //返回容器中与val相等的上下限的两个迭代器

unordered_set容器的迭代器
ust.begin(); //返回指向第一个元素的迭代器
ust.end(); //返回末尾的迭代器
ust.cbegin(); //返回指向第一个元素的const迭代器
ust.cend(); //返回末尾的const迭代器

unordered_multiset容器的迭代器
umst.begin(); //返回指向第一个元素的迭代器
umst.end(); //返回末尾的迭代器
umst.cbegin(); //返回指向第一个元素的const迭代器


umst.cend(); //返回末尾的const迭代器
unordered_set容器的互换
ust.swap(unordered_set &ust); // 将ust与ust的元素互换

unordered_multiset容器的互换
umst.swap(unordered_multiset &umst); // 将umst与umst的元素互换



#include <map>
map容器的构造函数
map<T1, T2> mp; //默认构造函数
map(const map &mp); //拷贝构造函数

multimap容器的构造函数
multimap<T1, T2> mmp; //默认构造函数
multimap(const multimap &mmp); //拷贝构造函数

map容器的赋值操作
map& operator=(const map &mp); //重载等号操作符

multimap容器的赋值操作
multimap& operator=(const multimap &mmp); //重载等号操作符

map容器的大小操作
mp.empty(); //判断容器是否为空
mp.size(); //返回容器中元素的个数
mp.max_size(); //返回容器能容纳元素的最大个数

multimap容器的大小操作
mmp.empty(); //判断容器是否为空
mmp.size(); //返回容器中元素的个数
mmp.max_size(); //返回容器能容纳元素的最大个数

map容器的插入和删除操作
mp.insert(const value_type& val); //在容器中插入元素
mp.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mp.erase(const_iterator position); //删除position迭代器所指的元素
mp.erase(const value_type& val); //删除容器中值为val的元素
mp.erase(first, last); //删除区间[first, last)中的所有元素
mp.clear(); //清空所有元素

multimap容器的插入和删除操作
mmp.insert(const value_type& val); //在容器中插入元素
mmp.insert(const_iterator position, const value_type& val); //将val插入到position位置尽可能近的位置
mmp.erase(const_iterator position); //删除position迭代器所指的元素
mmp.erase(const value_type& val); //删除容器中值为val的元素
mmp.erase(first, last); //删除区间[first, last)中的所有元素
mmp.clear(); //清空所有元素

map容器的查找操作
mp.find( const key_type& key); //查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mp.count(const key_type& key); //返回容器中键为key的元素个数
mp.lower_bound(const key_type& key); //返回第一个>=key元素的迭代器
mp.upper_bound(const key_type& key); //返回第一个>key元素的迭代器
mp.equal_range(const key_type& key); //返回容器中与key相等的上下限的两个迭代器

multimap容器的查找操作
mmp.find( const key_type& key); //查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mmp.count(const key_type& key); //返回容器中键为key的元素个数
mmp.lower_bound(const key_type& key); //返回第一个>=key元素的迭代器
mmp.upper_bound(const key_type& key); //返回第一个>key元素的迭代器
mmp.equal_range(const key_type& key); //返回容器中与key相等的上下限的两个迭代器

map容器的迭代器
mp.begin(); //返回指向第一个元素的迭代器
mp.end(); //返回末尾的迭代器

multimap容器的迭代器
mmp.begin(); //返回指向第一个元素的迭代器
mmp.end(); //返回末尾的迭代器

map容器的互换
mp.swap(map &mp); // 将mp与mp的元素互换

#include <unordered_map>
unordered_map容器的构造函数
unordered_map<T1, T2> ump; //默认构造函数
unordered_map(const unordered_map &ump); //拷贝构造函数

unordered_multimap容器的构造函数
unordered_multimap<T1, T2> ummp; //默认构造函数
unordered_multimap(const unordered_multimap &ummp); //拷贝构造函数
	
unordered_map容器的赋值操作
unordered_map& operator=(const unordered_map &ump); //重载等号操作符

unordered_multimap容器的赋值操作
unordered_multimap& operator=(const unordered_multimap &ummp); //重载等号操作符

unordered_map容器的大小操作
ump.empty(); //判断容器是否为空
ump.size(); //返回容器中元素的个数
ump.max_size(); //返回容器能容纳元素的最大个数

unordered_multimap容器的大小操作
ummp.empty(); //判断容器是否为空
ummp.size(); //返回容器中元素的个数
ummp.max_size(); //返回容器能容纳元素的最大个数

unordered_map容器的插入和删除操作
ump.insert(const value_type& val); //在容器中插入元素
ump.erase(const key_type& key); //删除容器中键为key的元素
ump.erase(const_iterator position); //删除position迭代器所指的元素
ump.erase(const_iterator first, const_iterator last); //删除区间[first, last)中的所有元素
ump.clear(); //清空所有元素


#include <stack>
stack容器的构造函数
stack<T> stk; //默认构造函数
stack(const stack &stk); //拷贝构造函数

stack容器的赋值操作
stack& operator=(const stack &stk); //重载等号操作符

stack容器的大小操作
stk.empty(); //判断堆栈是否为空
stk.size(); //返回堆栈中元素的个数

stack容器的数据存取
stk.top(); //返回栈顶元素
stk.push(); //向栈顶添加元素
stk.pop(); //从栈顶移除元素

stack容器的互换
stk.swap(stack &stk); // 将stk与stk的元素互换




#include <queue>
queue容器的构造函数
queue<T> que; //默认构造函数
queue(const queue &que); //拷贝构造函数

queue容器的赋值操作
queue& operator=(const queue &que); //重载等号操作符

queue容器的大小操作
que.empty(); //判断队列是否为空
que.size(); //返回队列中元素的个数

queue容器的数据存取
que.front(); //返回队列第一个元素
que.back(); //返回队列最后一个元素
que.push(); //向队列尾部添加元素
que.pop(); //从队列头部移除元素

queue容器的互换
que.swap(queue &que); // 将que与que的元素互换

priority_queue容器的构造函数
priority_queue<T> pque; //默认构造函数

priority_queue容器的赋值操作
priority_queue& operator=(const priority_queue &pque); //重载等号操作符
	
priority_queue容器的大小操作
pque.empty(); //判断队列是否为空
pque.size(); //返回队列中元素的个数

priority_queue容器的数据存取
pque.top(); //返回队列中优先级最高的元素
pque.push(); //向队列中添加元素
pque.pop(); //从队列中移除优先级最高的元素

priority_queue容器的互换
pque.swap(priority_queue &pque); // 将pque与pque的元素互换

#include <algorithm>
仿函数
less<T> //升序排列
greater<T> //降序排列
plus<T> //加法仿函数
minus<T> //减法仿函数
multiplies<T> //乘法仿函数
divides<T> //除法仿函数
modulus<T> //取模仿函数
negate<T> //取反仿函数

普通仿函数使用格式：
仿函数名字对象(参数)
例如：
plus<int> intAdd;
intAdd(10, 20); //等价于10+20


函数对象
函数对象是一个类，类中重载了()操作符的对象
函数对象的好处是可以像普通函数那样调用，可以有自己的状态
函数对象的调用可以有参数，也可以有返回值
函数对象可以作为参数传递给函数
函数对象可以作为函数的返回值
例如：
class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

MyAdd myAdd;
myAdd(10, 20); //等价于10+20


查找算法：适用于所有容器
find(iterator start, iterator end, value); //查找指定范围内的指定元素，找到返回指向该元素的迭代器，找不到返回end迭代器
find_if(iterator start, iterator end, _Pred); //查找指定范围内满足条件_Pred的元素，找到返回指向该元素的迭代器，找不到返回end迭代器
adjacent_find(iterator start, iterator end); //查找指定范围内相邻重复元素的第一个元素，找到返回指向该元素的迭代器，找不到返回end迭代器
binary_search(iterator start, iterator end, value); //查找指定范围内是否存在指定元素，找到返回true，找不到返回false
count(iterator start, iterator end, value); //统计指定范围内指定元素的个数
count_if(iterator start, iterator end, _Pred); //统计指定范围内满足条件_Pred的元素的个数


排序算法：适用于所有容器
random_shuffle(iterator start, iterator end); //对指定范围内的元素进行随机调整
sort(iterator start, iterator end); //对指定范围内的元素进行排序
sort(iterator start, iterator end, _Pred); //对指定范围内的元素进行排序，指定排序规则
stable_sort(iterator start, iterator end); //对指定范围内的元素进行稳定排序
stable_sort(iterator start, iterator end, _Pred); //对指定范围内的元素进行稳定排序，指定排序规则

拷贝和替换算法：适用于所有容器
copy(iterator start, iterator end, iterator dest); //将指定范围内的元素拷贝到另一容器中
replace(iterator start, iterator end, old_value, new_value); //将指定范围内的旧元素替换为新元素
replace_if(iterator start, iterator end, _Pred, new_value); //将指定范围内满足条件_Pred的元素替换为新元素


遍历算法：适用于所有容器
for_each(iterator start, iterator end, _Func); //对指定范围内的元素进行遍历，_Func可以是函数指针，函数对象，函数，Lambda表达式等
transform(iterator start, iterator end, dest, _Func); //对指定范围内的元素进行转换，_Func可以是函数指针，函数对象，函数，Lambda表达式等


#include <numeric>
算数生成算法：适用于所有容器
accumulate(iterator start, iterator end, init); //计算指定范围内的元素累计总和
fill(iterator start, iterator end, value); //将指定范围内的元素填充为指定值

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/384880.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

CSS之盒模型

CSS之盒模型

盒模型概念 浏览器盒模型&#xff08;Box Model&#xff09;是CSS中的基本概念&#xff0c;它描述了元素在布局过程中如何占据空间。盒模型由内容&#xff08;content&#xff09;、内边距&#xff08;padding&#xff09;、边框&#xff08;border&#xff09;、和外边距&…
阅读更多...
mysql Day05

mysql Day05

sql性能分析 sql执行频率 show global status like Com_______ 慢查询日志 执行时间超过10秒的sql语句 profile详情 show profiles帮助我们了解时间都耗费到哪里了 #查看每一条sql的耗时情况 show profiles#查看指定query_id的sql语句各个阶段的耗时情况 show profile fo…
阅读更多...
【项目日记(九)】项目整体测试,优化以及缺陷分析

【项目日记(九)】项目整体测试,优化以及缺陷分析

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:项目日记-高并发内存池⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你做项目   &#x1f51d;&#x1f51d; 开发环境: Visual Studio 2022 项目日…
阅读更多...
Spring Cloud Gateway 网关路由

Spring Cloud Gateway 网关路由

一、路由断言 路由断言就是判断路由转发的规则 二、路由过滤器 1. 路由过滤器可以实现对网关请求的处理&#xff0c;可以使用 Gateway 提供的&#xff0c;也可以自定义过滤器 2. 路由过滤器 GatewayFilter&#xff08;默认不生效&#xff0c;只有配置到路由后才会生效&#x…
阅读更多...
无人机飞行原理，多旋翼无人机飞行原理详解

无人机飞行原理，多旋翼无人机飞行原理详解

多旋翼无人机升空飞行的首要条件是动力&#xff0c;有了动力才能驱动旋粪旋转&#xff0c;才能产生克服重力所必需的升力。使旋翼产生升力&#xff0c;进而推动多旋翼无人机升空飞行的一套设备装置称为动力装置&#xff0c;包括多旋翼无人机的发动机以及保证发动机正常工作所必…
阅读更多...
LibreOffice Calc 取消首字母自动大写 (Capitalize first letter of every sentence)

LibreOffice Calc 取消首字母自动大写 (Capitalize first letter of every sentence)

LibreOffice Calc 取消首字母自动大写 [Capitalize first letter of every sentence] 1. Tools -> AutoCorrect Options2. AutoCorrect -> Options -> Capitalize first letter of every sentenceReferences 1. Tools -> AutoCorrect Options 2. AutoCorrect ->…
阅读更多...
论文介绍 One-step Diffusion 只需单步扩散生成！

论文介绍 One-step Diffusion 只需单步扩散生成！

论文介绍 One-step Diffusion with Distribution Matching Distillation 关注微信公众号: DeepGo 源码地址&#xff1a; https://tianweiy.github.io/dmd/ 论文地址&#xff1a; https://arxiv.org/abs/2311.18828 这篇论文介绍了一种新的图像生成方法&#xff0c;名为分布匹配…
阅读更多...
C++三剑客之std::optional(一) : 使用详解

C++三剑客之std::optional(一) : 使用详解

相关文章系列 C三剑客之std::optional(一) : 使用详解 C三剑客之std::any(一) : 使用 C之std::tuple(一) : 使用精讲(全) C三剑客之std::variant(一) : 使用 C三剑客之std::variant(二)&#xff1a;深入剖析 目录 1.概述 2.构建方式 2.1.默认构造 2.2.移动构造 2.3.拷贝构…
阅读更多...
前端vue 数字 字符串 丢失精度问题

前端vue 数字 字符串 丢失精度问题

1.问题 后端返回的数据 是这样的 一个字符串类型的数据 前端要想显示这个 肯定需要使用Json.parse() 转换一下 但是 目前有一个问题 转换的确可以 showId:1206381711026823172 有一个这样的字段 转换了以后 发现 字段成了1206381711026823200 精度直接丢了 原本的数据…
阅读更多...
假期作业 8

假期作业 8

1、若有以下说明语句&#xff1a;int a[12]{1,2,3,4,5,6,7,8,9,10,11,12};char c’a’,d,g;则数值为4的表达式是&#xff08; B&#xff09;。 A&#xff09;a[g-c] B&#xff09;a[4] C&#xff09;a[‘d’-‘c’] D&#xff09;a[‘d’-c] 2、假…
阅读更多...
【C++ 02】类和对象 1：初识类和对象

【C++ 02】类和对象 1：初识类和对象

文章目录 &#x1f308; Ⅰ 面向对象介绍&#x1f308; Ⅱ 类的引入&#x1f308; Ⅲ 类的定义格式1. 声明和定义不分离2. 声明和定义分离 &#x1f308; Ⅳ 类的访问限定符&#x1f308; Ⅴ 类的作用域&#x1f308; Ⅵ 类的实例化&#x1f308; Ⅶ this 指针 &#x1f308; Ⅰ…
阅读更多...
【Java程序设计】【C00254】基于Springboot的java学习平台（有论文）

【Java程序设计】【C00254】基于Springboot的java学习平台（有论文）

基于Springboot的java学习平台&#xff08;有论文&#xff09;&#xff09; 项目简介项目获取开发环境项目技术运行截图 项目简介 这是一个基于Springboot的学习平台 本系统分为系统功能模块、管理员功能模块、教师功能模块以及学生功能模块。 系统功能模块&#xff1a;在平台…
阅读更多...
LLM大模型常见问题解答（3）

LLM大模型常见问题解答（3）

简要描述下列概念在大语言模型中的作用 Transformer 架构Attention 机制预训练与微调过拟合和欠拟合 Transformer 架构 Transformer是一种基于自注意力机制的深度学习模型&#xff0c;它在论文“Attention Is All You Need”中首次提出。与此前流行的循环神经网络&#xff0…
阅读更多...
第四节 zookeeper集群与分布式锁

第四节 zookeeper集群与分布式锁

目录 1. Zookeeper集群操作 1.1 客户端操作zk集群 1.2 模拟集群异常操作 1.3 curate客户端连接zookeeper集群 2. Zookeeper实战案例 2.1 创建项目引入依赖 2.2 获取zk客户端对象 2.3 常用API 2.4 客户端向服务端写入数据流程 2.5 服务器动态上下线、客户端动态监听 2…
阅读更多...
力扣题目训练（8）

力扣题目训练（8）

2024年2月1日力扣题目训练 2024年2月1日力扣题目训练404. 左叶子之和405. 数字转换为十六进制数409. 最长回文串116. 填充每个节点的下一个右侧节点指针120. 三角形最小路径和60. 排列序列 2024年2月1日力扣题目训练 2024年2月1日第八天编程训练&#xff0c;今天主要是进行一些…
阅读更多...
AcWing 802. 区间和 离散化

AcWing 802. 区间和 离散化

文章目录 题目链接题目描述解题思路代码实现总结 题目链接 链接: AcWing 802. 区间和 题目描述 解题思路 离散化是一种常用的技巧&#xff0c;它能够将原始的连续数值转换为一组离散的值&#xff0c;从而简化问题的处理。在这段代码中&#xff0c;离散化的过程主要分为三个步…
阅读更多...
探索Nginx：强大的开源Web服务器与反向代理

探索Nginx：强大的开源Web服务器与反向代理

一、引言 随着互联网的飞速发展&#xff0c;Web服务器在现代技术架构中扮演着至关重要的角色。Nginx&#xff08;发音为“engine x”&#xff09;是一个高性能的HTTP和反向代理服务器&#xff0c;也是一个IMAP/POP3/SMTP代理服务器。Nginx因其卓越的性能、稳定性和灵活性&…
阅读更多...
02.数据结构

02.数据结构

一、链表 作用&#xff1a;用于写邻接表&#xff1b; 邻接表作用&#xff1a;用于存储图或树&#xff1b; 1、用数组模拟单链表 #include<iostream> using namespace std;const int N 100010;// head 表示头结点的下标 // e[i] 表示结点i的值 // ne[i] 表示结点i的ne…
阅读更多...
前端工程化面试题 | 08.精选前端工程化高频面试题

前端工程化面试题 | 08.精选前端工程化高频面试题

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
DS Wannabe之5-AM Project: DS 30day int prep day14

DS Wannabe之5-AM Project: DS 30day int prep day14

Q1. What is Autoencoder? 自编码器是什么&#xff1f; 自编码器是一种特殊类型的神经网络&#xff0c;它通过无监督学习尝试复现其输入数据。它通常包含两部分&#xff1a;编码器和解码器。编码器压缩输入数据成为一个低维度的中间表示&#xff0c;解码器则从这个中间表示重…
阅读更多...
最新文章

Copyright @ 2022~2023