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); //将指定范围内的元素填充为指定值

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【51单片机】LED点阵屏（江科大）

【51单片机】LED点阵屏（江科大）

9.1LED点阵屏 1.LED点阵屏介绍 LED点阵屏由若干个独立的LED组成,LED以矩阵的形式排列,以灯珠亮灭来显示文字、图片、视频等。 2.LED点阵屏工作原理 LED点阵屏的结构类似于数码管,只不过是数码管把每一列的像素以“8”字型排列而已。原理图如下 每一行的阳极连在一起,每一列…
阅读更多...
一周学会Django5 Python Web开发-Django5操作命令

一周学会Django5 Python Web开发-Django5操作命令

锋哥原创的Python Web开发 Django5视频教程&#xff1a; 2024版 Django5 Python web开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili2024版 Django5 Python web开发 视频教程(无废话版) 玩命更新中~共计11条视频&#xff0c;包括&#xff1a;2024版 Django5 Python we…
阅读更多...
2024.2.12日总结

2024.2.12日总结

今天去拜年去了&#xff0c;白天基本上都在外面&#xff0c;明天也是要去拜年&#xff0c;这几天学习的时间挺少的&#xff0c;但是还是要抓紧这些时间快点写项目&#xff0c;要找一些好用的插件&#xff0c;把项目和仓库新建好&#xff0c;然后下一步按照原型图的样子把页面画…
阅读更多...
基础IO[一]

基础IO[一]

文件文件内容属性 文件在硬盘上放着&#xff0c;我们的流程->写代码->编译->运行->访问文件。那么本质上是谁在访问&#xff1f; 是进程在访问。进程访问文件是需要通过接口来访问。 文件在磁盘上放着&#xff0c;要向硬件写入文件&#xff0c;谁有权限呢?必须…
阅读更多...
java之Maven

java之Maven

1. maven Maven是管理和构建java项目的工具 项目依赖资源(jar包)的管理,避免版本冲突统一项目结构项目构建&#xff0c;标准跨平台(Linux,window,MacOS)的自动化项目管理 2.maven依赖仓库 2.maven安装 maven安装视频教程 3. IDEA集成Maven 4. maven的依赖范围 5. maven生命…
阅读更多...
从基建发力，CESS 如何推动 RWA 发展？

从基建发力，CESS 如何推动 RWA 发展？

2023 年 11 月 30 日&#xff0c;Web3 基金会&#xff08;Web3 Foundation&#xff09;宣布通过 Centrifuge 将部分资金投资于 RWA&#xff08;Real World Assets&#xff0c;真实世界资产&#xff09;&#xff0c;试点投资为 100 万美元。Web3 基金会旨在通过支持专注于隐私、…
阅读更多...
代码随想录刷题笔记 DAY 24 | 回溯算法理论基础 | 组合问题 No. 77

代码随想录刷题笔记 DAY 24 | 回溯算法理论基础 | 组合问题 No. 77

文章目录 Day 2401. 回溯算法理论基础1.1 什么是回溯法&#xff1f;1.2 为什么要使用回溯法&#xff1f;1.3 如何理解回溯法&#xff1f; 02. 组合问题&#xff08;No. 77&#xff09;2.1 题目2.2 笔记2.3 代码 Day 24 01. 回溯算法理论基础 1.1 什么是回溯法&#xff1f; &…
阅读更多...
网络安全检查表

网络安全检查表

《网络攻击检查表》 1.应用安全漏洞 2.弱口令&#xff0c;默认口令 3.服务器互联网暴露 4.操作系统&#xff0c;中间件安全漏洞 5.研发服务器&#xff0c;邮件服务器等安全检查
阅读更多...
python+django高校活动报名场地管理系统l1ro4

python+django高校活动报名场地管理系统l1ro4

校园活动管理平台程序的开发&#xff0c;在数据库的选择上面&#xff0c;选择功能强大的MySQL数据库进行数据的存放操作。 技术栈 后端&#xff1a;python 前端&#xff1a;vue.jselementui 框架&#xff1a;django Python版本&#xff1a;python3.7 数据库&#xff1a;mysql5…
阅读更多...
交叉熵损失函数（Cross-Entropy Loss）的基本概念与程序代码

交叉熵损失函数（Cross-Entropy Loss）的基本概念与程序代码

交叉熵损失函数&#xff08;Cross-Entropy Loss&#xff09;是机器学习和深度学习中常用的损失函数之一&#xff0c;用于分类问题。其基本概念如下&#xff1a; 1. 基本解释&#xff1a; 交叉熵损失函数衡量了模型预测的概率分布与真实概率分布之间的差异。在分类问题中&…
阅读更多...
apk反编译修改教程系列---简单修改apk默认横竖屏显示 手机端与电脑端同步演示【十一】

apk反编译修改教程系列---简单修改apk默认横竖屏显示 手机端与电脑端同步演示【十一】

往期教程&#xff1a; apk反编译修改教程系列-----修改apk应用名称 任意修改名称 签名【一】 apk反编译修改教程系列-----任意修改apk版本号 版本名 防止自动更新【二】 apk反编译修改教程系列-----修改apk中的图片 任意更换apk桌面图片【三】 apk反编译修改教程系列---简单…
阅读更多...
Impala-架构与设计

Impala-架构与设计

架构与设计 一、背景和起源二、框架概述1.设计特点2.框架优点3.框架限制 三、架构图1.Impala Daemon2.Statestore3.Catalog 四、Impala查询流程1.发起查询2.生成执行计划3.分配任务4.交换中间数据5.汇集结果6.返回结果 总结参考链接 一、背景和起源 现有的大数据查询分析工具H…
阅读更多...
Microsoft Word 超链接

Microsoft Word 超链接

Microsoft Word 超链接 1. 取消超链接2. 自动超链接2.1. 选项2.2. 校对 -> 自动更正选项2.3. Internet 及网络路径替换为超链接 References 1. 取消超链接 Ctrl A -> Ctrl Shift F9 2. 自动超链接 2.1. 选项 2.2. 校对 -> 自动更正选项 ​​​ 2.3. Internet…
阅读更多...
AES加密后的密码可以破解吗

AES加密后的密码可以破解吗

AES&#xff08;高级加密标准&#xff09;是一种广泛使用的对称加密算法&#xff0c;设计用来抵御各种已知的攻击方法。AES使用固定块大小的加密块和密钥长度&#xff0c;通常是128、192或256位。它被认为是非常安全的&#xff0c;到目前为止&#xff0c;没有已知的可行方法能够…
阅读更多...
【详解】斗地主随机发牌项目

【详解】斗地主随机发牌项目

目录 前言&#xff1a; 1.初始化牌 2.洗牌 3.揭牌 总代码&#xff1a; Card类&#xff1a; CardGame类&#xff1a; Main类&#xff1a; 结语&#xff1a; 前言&#xff1a; 斗地主是全国范围内的一种桌面游戏&#xff0c;本节我们来实现一下斗地主中的简单初始化牌、…
阅读更多...
Spring Boot 笔记 006 创建接口_注册

Spring Boot 笔记 006 创建接口_注册

1.1 由于返回数据都是以下这种格式&#xff0c;那么久再编写一个result实体类 报错了&#xff0c;原因是没有构造方法 可以使用lombok的注解自动生成&#xff0c;添加无参的构造器和全参的构造器 package com.geji.pojo;import lombok.AllArgsConstructor; import lombok.NoArg…
阅读更多...
【MySQL】操作库 —— 库的操作 -- 详解

【MySQL】操作库 —— 库的操作 -- 详解

一、增删数据库 1、创建数据库 create database db_name; 本质就是在 /var/lib/mysql 创建一个目录。 说明&#xff1a; 大写的表示关键字。[ ] 是可选项。CHARACTER SET&#xff1a;指定数据库采用的字符集。COLLATE&#xff1a;指定数据库字符集的校验规则。 2、数据库删除…
阅读更多...
Linux第51步_移植ST公司的linux内核第3步_添加修改设备树

Linux第51步_移植ST公司的linux内核第3步_添加修改设备树

1、设备树文件的路径 1)、创建linux中的设备树头文件 在“my_linux/linux-5.4.31/arch/arm/boot/dts/”目录中&#xff0c;以“stm32mp15xx-edx.dtsi”为蓝本&#xff0c;复制一份&#xff0c;并命名为 “stm32mp157d-atk.dtsi”&#xff0c;这就是我们开发板的设备树头文件。…
阅读更多...
【stomp实战】Springboot+Stomp协议实现聊天功能

【stomp实战】Springboot+Stomp协议实现聊天功能

本示例实现一个功能&#xff0c;前端通过websocket发送消息给后端服务&#xff0c;后端服务接收到该消息时&#xff0c;原样将消息返回给前端。前端技术栈htmlstomp.js&#xff0c;后端SpringBoot 前端代码 关于stomp客户端的开发&#xff0c;如果不清楚的&#xff0c;可以看…
阅读更多...
机器学习10-特征缩放

机器学习10-特征缩放

特征缩放的目的是确保不同特征的数值范围相近&#xff0c;使得模型在训练过程中更加稳定&#xff0c;加速模型收敛&#xff0c;提高模型性能。具体而言&#xff0c;零均值和单位方差的目标有以下几点好处&#xff1a; 1. 均值为零&#xff08;Zero Mean&#xff09;&#xff1a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023