浅谈C++|STL之list+forward_list篇

在这里插入图片描述
一.list基本概念

功能:将数据进行链式存储

链表（list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成:链表由—系列结点组成

结点的组成:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

在这里插入图片描述

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点:
·采用动态存储分配，不会造成内存浪费和溢出
·链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点:
·链表灵活，但是空间(指针域)和时间(遍历)额外耗费较大
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结:STL中List和vector是两个最常被使用的容器，各有优缺点

二.list构造函数

以下是在每个构造函数后添加的示例代码：

  1. 默认构造函数：
std::list<int> myList;  // 创建一个空的 int 类型的双向链表容器
  1. 带有元素个数参数的构造函数：
std::list<int> myList(5, 10);  // 创建一个包含 5 个值为 10 的 int 类型的双向链表容器
  1. 区间构造函数：
std::vector<int> myVector = {1, 2, 3, 4, 5};
std::list<int> myList(myVector.begin() + 1, myVector.end() - 1);  // 创建一个包含 myVector 中除了第一个和最后一个元素的剩余元素的双向链表容器
  1. 拷贝构造函数：
std::list<int> originalList = {1, 2, 3, 4, 5};
std::list<int> copiedList(originalList);  // 创建一个拷贝 originalList 的新双向链表容器
  1. 移动构造函数：
std::list<int> originalList = {1, 2, 3, 4, 5};
std::list<int> movedList(std::move(originalList));  // 创建一个移动 originalList 元素到新双向链表容器中的新容器
  1. 初始化列表构造函数：
std::list<int> myList = {1, 2, 3, 4, 5};  // 使用初始化列表中的元素初始化一个 int 类型的双向链表容器
构造函数示例
默认构造函数std::list<int> myList;
带有元素个数参数的构造函数std::list<int> myList(5, 10);
区间构造函数std::vector<int> myVector = {1, 2, 3, 4, 5};
std::list<int> myList(myVector.begin() + 1, myVector.end() - 1);
拷贝构造函数std::list<int> originalList = {1, 2, 3, 4, 5};
std::list<int> copiedList(originalList);
移动构造函数std::list<int> originalList = {1, 2, 3, 4, 5};
std::list<int> movedList(std::move(originalList));
初始化列表构造函数std::list<int> myList = {1, 2, 3, 4, 5};

三.list赋值和交换

当涉及到赋值、交换和 assign 函数时，你可以使用以下方法来操作 std::list 容器：

  1. 赋值操作符（operator=）：

    std::list<int> list1 = {1, 2, 3, 4, 5};
std::list<int> list2;// 使用赋值操作符将 list1 中的元素赋值给 list2
list2 = list1;

  2. swap 函数：

    std::list<int> list1 = {1, 2, 3, 4, 5};
std::list<int> list2 = {10, 20, 30};// 使用 swap 函数交换 list1 和 list2 中的所有元素
list1.swap(list2);// 或者使用 std::swap
std::swap(list1, list2);

  3. assign 函数：

    std::list<int> myList;// 使用 assign 函数将特定值赋给 myList
myList.assign(5, 10);// 使用 assign 函数将范围内的元素赋给 myList
std::vector<int> myVector = {1, 2, 3, 4, 5};
myList.assign(myVector.begin() + 1, myVector.end() - 1);// 使用 assign 函数使用初始化列表中的元素进行赋值给 myList
myList.assign({1, 2, 3, 4, 5});

通过使用这些操作，你可以方便地在 std::list 容器中进行赋值、交换和赋特定值、赋范围以及使用初始化列表进行赋值的操作。请记住，在这些操作之后，原容器中的元素将被替换为新赋值的元素，原容器中的迭代器、引用和指针等将不再有效。

操作示例
赋值操作符（operator=）std::list<int> list1 = {1, 2, 3, 4, 5};
std::list<int> list2;
list2 = list1;
swap 函数std::list<int> list1 = {1, 2, 3, 4, 5};
std::list<int> list2 = {10, 20, 30};
list1.swap(list2);
// 或者使用 std::swap
std::swap(list1, list2);
assign 函数std::list<int> myList;
myList.assign(5, 10);
std::vector<int> myVector = {1, 2, 3, 4, 5};
myList.assign(myVector.begin() + 1, myVector.end() - 1);
myList.assign({1, 2, 3, 4, 5});

四.list大小操作

当涉及到获取和调整 std::list 的大小时，你可以使用以下函数：

  1. 获取大小：

    • size 函数：返回列表中元素的数量。
    • max_size 函数：返回列表所能容纳的最大元素数量。
    • empty 函数：检查列表是否为空。

    示例：

    std::list<int> myList = {1, 2, 3, 4, 5};size_t length = myList.size();              // 获取列表的大小
size_t maxSize = myList.max_size();          // 返回列表能够容纳的最大元素数量
bool isEmpty = myList.empty();               // 检查列表是否为空

  2. 调整大小：

    • resize 函数：调整列表的大小。
    • clear 函数：清空列表中的所有元素。

    示例：

    std::list<int> myList = {1, 2, 3, 4, 5};myList.resize(10);               // 调整列表的大小为 10
myList.resize(8, 0);             // 调整列表的大小为 8，并插入值为 0 的元素
myList.clear();                  // 清空列表中的所有元素

通过使用这些函数，你可以方便地获取列表的大小、最大容量以及检查列表是否为空。同时，你也可以调整列表的大小或清空列表中的元素。请根据实际需求选择适合的函数来操作 std::list 容器。
下面是整理成表格的关于获取和调整 std::list 大小的函数接口及示例：

操作示例描述
获取大小std::list<int>::size()返回列表中元素的数量。
获取最大容量std::list<int>::max_size()返回列表所能容纳的最大元素数量。
检查是否为空std::list<int>::empty()检查列表是否为空。
调整大小std::list<int>::resize(size_type count)调整列表的大小。
带默认值的调整大小std::list<int>::resize(size_type count, const T& value)调整列表的大小，并插入默认值元素。
清空列表std::list<int>::clear()清空列表中的所有元素。

示例：

#include <list>
#include <iostream>int main() {std::list<int> myList = {1, 2, 3, 4, 5};// 获取大小size_t length = myList.size();              // 获取列表的大小std::cout << "Size: " << length << std::endl;// 获取最大容量size_t maxSize = myList.max_size();          // 返回列表能够容纳的最大元素数量std::cout << "Max Size: " << maxSize << std::endl;// 检查是否为空bool isEmpty = myList.empty();               // 检查列表是否为空std::cout << "Is Empty: " << std::boolalpha << isEmpty << std::endl;// 调整大小myList.resize(10);               // 调整列表的大小为 10myList.resize(8, 0);             // 调整列表的大小为 8，并插入值为 0 的元素// 清空列表myList.clear();                  // 清空列表中的所有元素return 0;
}

五.list的插入和删除

在C++中，使用STL的list容器可以实现高效的插入和删除操作。以下是关于list的插入和删除的一些基本操作：

  1. 插入元素：
    • 在列表头部插入元素：使用push_front()函数。
    • 在列表尾部插入元素：使用push_back()函数。
    • 在指定位置之前插入元素：使用insert()函数，传递需要插入的位置和要插入的元素的值。
std::list<int> myList;
myList.push_front(10);  // 在头部插入元素
myList.push_back(20);   // 在尾部插入元素
auto it = std::next(myList.begin());  // 获取迭代器指向第一个元素之后的位置
myList.insert(it, 15);  // 在指定位置之前插入元素
myList.insert(it, 150，15);  // 在指定位置之前插入150个元素
myList.insert(myList.begin()，myList.end（）);  // 迭代器插入
  1. 删除元素：
    • 删除列表头部的元素：使用pop_front()函数。
    • 删除列表尾部的元素：使用pop_back()函数。
    • 删除指定位置的元素：使用erase()函数，传递要删除的元素的位置。
std::list<int> myList;
myList.push_back(10);
myList.push_back(20);
myList.push_back(30);
myList.pop_front();  // 移除头部元素
myList.pop_back();   // 移除尾部元素
auto it = std::next(myList.begin());  // 获取迭代器指向第一个元素之后的位置
myList.erase(it);    // 移除指定位置的元素
myList.erase(myList.begin()，myList.end（）);    // 移除指定区间的元素
  1. remove()函数用于删除list容器中所有与指定值相等的元素。它会对容器进行遍历，将符合条件的元素删除。以下是示例代码：
std::list<int> myList { 10, 20, 30, 40, 10, 50 };myList.remove(10); // 删除所有值为10的元素// 打印剩余的元素
for (const auto& elem : myList) {std::cout << elem << " ";
}
// 输出: 20 30 40 50
  1. clear()函数用于清空整个list容器，将其变为空列表。以下是示例代码：
std::list<int> myList { 10, 20, 30 };myList.clear(); // 清空liststd::cout << "Size of list: " << myList.size() << std::endl; // 输出: 0

remove()函数删除所有与指定值相等的元素，而非删除指定位置的元素。若要删除指定位置的元素，仍需使用erase()函数。

list容器支持常数时间复杂度的插入和删除操作，但在访问和查找元素方面相对较差。同时，list容器不支持随机访问，只能通过迭代器进行访问。

auto是什么？

在C++11及以后的版本中，可以使用关键字auto来自动推导变量的类型。当使用auto声明变量时，编译器会根据变量的初始化值来推导出变量的类型。

在上述示例代码中，auto被用于声明一个迭代器it，通过调用std::next()函数来获取myList中第一个元素之后的位置。std::next()函数返回一个迭代器，而使用auto让编译器根据返回值来自动推导出it的类型，以保证类型匹配。

使用auto关键字的好处是可以简化代码，减少类型声明的冗余，并且在某些情况下可以更灵活地处理不同类型的变量。然而，需要注意的是，auto并不是完全的类型推导，它只能在编译时确定变量的类型，而不能用于运行时动态类型的情况。

接口描述
insert(pos, value)在指定位置之前插入一个元素，并返回指向新插入元素的迭代器。
insert(pos, count, value)在指定位置之前插入多个相同值的元素，并返回指向第一个新插入元素的迭代器。
insert(pos, first, last)在指定位置之前插入另一个迭代器范围内的元素，并返回指向第一个新插入元素的迭代器。
emplace(pos, args…)在指定位置之前就地构造一个元素，并返回指向插入元素的迭代器。此函数避免额外的拷贝或移动操作。
push_back(value)在容器末尾插入一个元素。
push_front(value)在容器开头插入一个元素。
pop_back()移除容器末尾的元素。
pop_front()移除容器开头的元素。
erase(pos)移除指定位置的元素，并返回指向被删除元素之后的一个元素的迭代器。
erase(first, last)移除一个迭代器范围内的元素，并返回指向最后一个被删除元素之后的一个元素的迭代器。
remove(value)移除容器中所有与给定值相等的元素。

六.数据存取和遍历

在这里插入图片描述

在C++的STL中，list容器是一个双向链表，其数据存取方式与使用索引进行访问的容器（例如vector）有所不同。

要访问list容器中的数据，可以使用迭代器。迭代器提供了一种访问容器元素的通用方式，而不需要依赖索引。以下是一些常用的数据存取操作：

  1. 访问首尾元素：
    • 使用front()函数可以访问容器的第一个元素。
    • 使用back()函数可以访问容器的最后一个元素。
std::list<int> myList { 10, 20, 30 };
int firstElement = myList.front();   // 访问第一个元素
int lastElement = myList.back();     // 访问最后一个元素
  1. 使用迭代器遍历元素：
    • 使用begin()函数获取指向容器第一个元素的迭代器。
    • 使用end()函数获取指向容器最后一个元素之后位置的迭代器。
std::list<int> myList { 10, 20, 30 };
for (auto it = myList.begin(); it != myList.end(); ++it) {// 使用迭代器访问元素int element = *it;// 进行操作
}
  1. 使用范围遍历语法：
    • 使用C++11引入的范围遍历语法，可以更简洁地遍历容器元素。
std::list<int> myList { 10, 20, 30 };
for (const auto& element : myList) {// 使用范围遍历访问元素// 进行操作
}

需要注意的是，由于list是一个双向链表，它不能像vector那样通过索引直接访问元素，因为链表的元素没有直接的索引位置。因此，在list中按索引进行访问或查找需要通过迭代器和线性搜索来实现。

加强for循环

当使用范围遍历语法时，可以更简洁地遍历容器元素，不需要显式地操作迭代器。以下是对第三种遍历方法的详细介绍：

  1. 范围遍历语法：

    std::list<int> myList { 10, 20, 30 };
for (const auto& element : myList) {// 使用范围遍历访问元素// 进行操作
}
    • myList是一个std::list<int>类型的容器，初始化了三个整型元素。
    • for循环遍历myList容器中的每个元素。
    • const auto& element定义了一个循环变量element，用于依次访问容器中的元素。auto关键字用于自动推导element的类型。
    • element是一个常量引用，可以以只读方式访问容器中的元素值。

  2. 范围遍历的优点：

    • 简洁：范围遍历语法更加简洁，不需要手动操作迭代器。
    • 安全：范围遍历中的循环变量为常量引用，防止意外修改元素。
    • 自动推导类型：使用auto关键字可以自动推导循环变量的类型，无需显式声明。

范围遍历适用于大多数容器类型，包括vector、list、set、map等。然而，范围遍历仅适用于对容器中元素的只读访问。如果需要对元素进行修改，可以将循环变量声明为非常量引用。

操作描述
front()访问容器的第一个元素。
back()访问容器的最后一个元素。
begin()获取指向容器第一个元素的迭代器。
end()获取指向容器最后一个元素之后位置的迭代器。
for-each (范围遍历语法)使用C++11引入的范围遍历语法，按顺序遍历容器中的每个元素。

七.反转和排序

  1. 反转（Reverse）：
    • 可以使用reverse()函数对std::list容器进行反转操作。
    • 这将会使容器中的元素逆序排列。

示例代码：

std::list<int> myList { 1, 2, 3, 4, 5 };
myList.reverse();  // 反转容器中的元素
  1. 排序（Sort）：
    • 可以使用sort()函数对std::list容器进行排序操作。
    • 默认情况下，sort()函数按升序对容器元素进行排序。
    • 也可以通过提供自定义的比较函数来实现自定义排序。

示例代码：

std::list<int> myList { 5, 3, 1, 4, 2 };
myList.sort();  // 按升序对容器中的元素进行排序

自定义排序的示例代码：

bool descendingOrder(int a, int b) {return a > b;
}std::list<int> myList { 5, 3, 1, 4, 2 };
myList.sort(descendingOrder);  // 按降序对容器中的元素进行排序

由于std::list是一个双向链表，排序操作可能比较耗时，因为它需要通过链表中的指针进行交换操作。而对于反转操作来说，它可以在常数时间内完成。

操作描述
reverse()反转容器中的元素。
sort()按升序对容器中的元素进行排序（默认）。
sort(comp)按指定的比较函数对容器中的元素进行排序，用于自定义排序规则。

八.函数接口

构造函数
list();默认构造函数
explicit list(const Allocator& alloc);带分配器的构造函数
explicit list(size_type count, const T& value = T(), const Allocator& alloc = Allocator());使用初始元素和分配器的构造函数
迭代器
iterator begin();返回指向首元素的迭代器
const_iterator begin() const;返回指向首元素的常量迭代器
iterator end();返回指向尾后元素的迭代器
const_iterator end() const;返回指向尾后元素的常量迭代器
reverse_iterator rbegin();返回指向尾元素的反向迭代器
const_reverse_iterator rbegin() const;返回指向尾元素的常量反向迭代器
reverse_iterator rend();返回指向首前元素的反向迭代器
const_reverse_iterator rend() const;返回指向首前元素的常量反向迭代器
容量
bool empty() const;检查列表是否为空
size_type size() const;返回列表中的元素数量
size_type max_size() const;返回列表可容纳的最大元素数量
元素访问
reference front();返回第一个元素的引用
const_reference front() const;返回第一个元素的常量引用
reference back();返回最后一个元素的引用
const_reference back() const;返回最后一个元素的常量引用
修改器
template <class... Args> void emplace_front(Args&&... args);在列表开始处插入元素
void push_front(const T& value);在列表开始处插入元素
void push_front(T&& value);在列表开始处插入移动元素
void pop_front();移除列表开始处的元素
template <class... Args> void emplace_back(Args&&... args);在列表末尾插入元素
void push_back(const T& value);在列表末尾插入元素
void push_back(T&& value);在列表末尾插入移动元素
void pop_back();移除列表末尾的元素
template <class... Args> iterator emplace(const_iterator pos, Args&&... args);在迭代器指定位置插入元素
iterator insert(const_iterator pos, const T& value);在迭代器指定位置插入元素
iterator insert(const_iterator pos, T&& value);在迭代器指定位置插入移动元素
iterator insert(const_iterator pos, size_type count, const T& value);在迭代器指定位置插入多个元素
template <class InputIterator> iterator insert(const_iterator pos, InputIterator first, InputIterator last);在迭代器指定位置插入范围内的元素
iterator erase(const_iterator pos);移除指定位置的元素
iterator erase(const_iterator first, const_iterator last);移除指定范围内的元素
void swap(list& other);交换两个列表的内容
void resize(size_type count);改变列表的大小
void resize(size_type count, const value_type& value);改变列表的大小并填充元素
void clear();移除列表中的所有元素
操作
void remove(const T& value);移除与指定值相等的所有元素
template <class Predicate> void remove_if(Predicate pred);移除满足谓词的所有元素
void unique();移除连续相等的元素
template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);根据二元谓词移除连续满足条件的元素
void merge(list& other);合并另一个列表
template <class Compare> void merge(list& other, Compare comp);根据比较函数合并另一个列表
void sort();对列表进行排序
template <class Compare> void sort(Compare comp);使用自定义比较函数对列表排序
void reverse();反转列表中元素的顺序
双向链表专属操作
void splice(const_iterator pos, list& other);将另一个列表合并到指定位置之前
void splice(const_iterator pos, list&& other);将右值引用的列表合并到指定位置之前
void splice(const_iterator pos, list& other, const_iterator it);将另一个列表中的一个元素移动到指定位置之前
void splice(const_iterator pos, list&& other, const_iterator it);将右值引用列表中的一个元素移动到指定位置之前
void splice(const_iterator pos, list& other, const_iterator first, const_iterator last);将另一个列表中的一段元素移动到指定位置之前
void splice(const_iterator pos, list&& other, const_iterator first, const_iterator last);将右值引用列表中的一段元素移动到指定位置之前
比较操作
bool operator==(const list& other) const;列表相等比较
bool operator!=(const list& other) const;列表不相等比较
bool operator<(const list& other) const;列表小于比较
bool operator<=(const list& other) const;列表小于等于比较
bool operator>(const list& other) const;列表大于比较
bool operator>=(const list& other) const;列表大于等于比较

九.forward_list单向链表

操作描述
emplace_front(args)在链表的前方插入一个元素，使用参数 args 构造元素。
push_front(value)在链表的前方插入一个已构造的元素。
pop_front()移除链表的第一个元素。
begin()返回指向链表开头的迭代器。
end()返回指向链表末尾之后位置的迭代器。
empty()检查链表是否为空。
size()返回链表中的元素个数。
erase_after(pos)移除链表中 pos 之后的元素。
insert_after(pos, value)在链表中 pos 之后插入一个已构造的元素。
resize(count)改变链表的大小，使其包含 count 个元素。
swap(other_list)交换两个链表的内容。

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

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

相关文章

腾讯云4核8G云服务器租用价格选轻量还是CVM？性能如何？

腾讯云4核8G云服务器租用价格选轻量还是CVM？性能如何？

腾讯云4核8G云服务器可以选择轻量应用服务器或CVM云服务器标准型S5实例&#xff0c;轻量4核8G12M服务器446元一年&#xff0c;CVM S5云服务器935元一年&#xff0c;相对于云服务器CVM&#xff0c;轻量应用服务器性价比更高&#xff0c;轻量服务器CPU和CVM有区别吗&#xff1f;性…
阅读更多...
基于YOLOv8模型的海洋生物目标检测系统（PyTorch+Pyside6+YOLOv8模型）

基于YOLOv8模型的海洋生物目标检测系统（PyTorch+Pyside6+YOLOv8模型）

摘要&#xff1a;基于YOLOv8模型的海洋生物目标检测系统可用于日常生活中检测与定位海洋生物目标&#xff0c;利用深度学习算法可实现图片、视频、摄像头等方式的目标检测&#xff0c;另外本系统还支持图片、视频等格式的结果可视化与结果导出。本系统采用YOLOv8目标检测算法训…
阅读更多...
腾讯云4核8G服务器选CVM还是轻量比较好？价格对比

腾讯云4核8G服务器选CVM还是轻量比较好？价格对比

腾讯云4核8G云服务器可以选择轻量应用服务器或CVM云服务器标准型S5实例&#xff0c;轻量4核8G12M服务器446元一年&#xff0c;CVM S5云服务器935元一年&#xff0c;相对于云服务器CVM&#xff0c;轻量应用服务器性价比更高&#xff0c;轻量服务器CPU和CVM有区别吗&#xff1f;性…
阅读更多...
半减器、全减器和减法器原理和设计

半减器、全减器和减法器原理和设计

减法器可由基础的半减器和全减器模块组成&#xff0c;或者基于加法器和控制信号搭建。定义N比特被减数X&#xff0c;减数Y,差为D&#xff08;difference&#xff09;&#xff1b;来自低比特借位Bi&#xff0c;向高比特借位Bi1,i为比特序号&#xff1b;所以&#xff0c;有以下结…
阅读更多...
在Kubernetes集群中部署 dolphindcheduler-3.1.8

在Kubernetes集群中部署 dolphindcheduler-3.1.8

温故知新 &#x1f4da;第一章 前言&#x1f4d7;背景&#x1f4d7;目的&#x1f4d7;总体方向 &#x1f4da;第二章 部署&#x1f4d7;安装helm&#x1f4d7;安装dolphindcheduler&#xff08;使用k8s的部署用户操作&#xff09;&#x1f4d5;通过命令验证&#x1f4d5;通过Ku…
阅读更多...
轻松学会寻找不同操作系统电脑的IP地址的技巧！

轻松学会寻找不同操作系统电脑的IP地址的技巧！

TCP/IP计算机网络使用两种IP地址——公共&#xff08;也称为外部&#xff09;和私有&#xff08;有时称为内部或本地&#xff09;。 在设置文件服务器或网站时&#xff0c;你可能需要公共IP地址&#xff0c;而专用IP地址对于与本地设备通信、转发路由器端口或访问路由器以进行…
阅读更多...
华为OD机考算法题：数字加减游戏

华为OD机考算法题：数字加减游戏

目录 题目部分 解读与分析 代码实现 题目部分 题目数字加减游戏难度难题目说明小明在玩一个数字加减游戏&#xff0c;只使用加法或者减法&#xff0c;将一个数字 s 变成数字 t 。 每个回合&#xff0c;小明可以用当前的数字加上或减去一个数字。 现在有两种数字可以用来加减…
阅读更多...
SAP ABAP基础知识 访问外部数据库-开发篇

SAP ABAP基础知识 访问外部数据库-开发篇

前言 本文主要介绍通过ABAP语言访问外部数据库的几种方式 一、外部数据库配置 本文示例中的代码访问了两个外部数据库 MTD : 外部oracle数据库,其中示例表 ZTTEMP 字段( ZZTNO,WERKS) S4Q : 外部HANA数据库(开发系统访问测试系统的数据库), 使用表USR02,ZTTEMP 二、ABAP访问…
阅读更多...
c语言练习58:⾃定义类型：结构体

c语言练习58:⾃定义类型：结构体

⾃定义类型&#xff1a;结构体 结构体的概念 结构是⼀些值的集合&#xff0c;这些值称为成员变量。结构的每个成员可以是不同类型的变量。 结构体是一个种自定义的数据类型&#xff0c;它可以由很多个默认数据类型组成。它主要用于描述复杂场景下的变量。 例如&#xff0c;想…
阅读更多...
前端深入理解JavaScript中的WeakMap和WeakSet

前端深入理解JavaScript中的WeakMap和WeakSet

&#x1f3ac; 岸边的风&#xff1a;个人主页 &#x1f525; 个人专栏 :《 VUE 》 《 javaScript 》 ⛺️ 生活的理想&#xff0c;就是为了理想的生活 ! 目录 1. WeakMap和WeakSet概述 1.1 WeakMap 1.2 WeakSet 2. WeakMap深入解析 2.1 WeakMap的创建和使用 2.2 WeakMap…
阅读更多...
软件流程图怎么画？详细画法看这里

软件流程图怎么画？详细画法看这里

软件流程图怎么画&#xff1f;软件流程图是软件开发过程中必不可少的一环&#xff0c;可以帮助开发人员更好地理解和规划软件开发的流程。在制作软件流程图的时候&#xff0c;我们可以使用一些制作工具。下面就给大家介绍一款好用的绘制工具。 我们可以使用【迅捷画图】来进行流…
阅读更多...
Android端Base64解码表情emoj乱码

Android端Base64解码表情emoj乱码

一、背景&#xff1a;H5端用户评论中包含表情包&#xff0c;通过JSBridge 传递给客户端&#xff0c;Android Base64解码之后&#xff0c;显示乱码&#xff08;是菱形问号&#xff09;。小程序和iOS可以正常解码出表情。用Base64在线编码解码&#xff08;Base64 在线编码解码 | …
阅读更多...
BOM操作

BOM操作

文章目录 BOM事件页面加载调整窗口事件定时器停止计时器Location对象History对象Offsetleft获取元素偏移Offset与style的区别可视区client系列滚动scroll系列Mouseover和mousenter区别 动画原理实现动画封装给不同对象添加定时器缓动动画原理多个位置间移动 BOM事件 页面加载 …
阅读更多...
BeanUtils.copyProperties的使用场景

BeanUtils.copyProperties的使用场景

1. 常见场景 我们如果有两个具有很多相同属性名的JavaBean对象a和b&#xff0c;想把a中的属性赋值到b&#xff0c;例如 接口中将接收到的前端请求参数XxxReqVo,我们想把这个入参转化为XxxQuery对象作为数据库的查询条件对象 传统做法是手动set&#xff0c;即 XxxBean xxxBea…
阅读更多...
Python Opencv实践 - HoG特征计算

Python Opencv实践 - HoG特征计算

参考资料&#xff1a;https://www.cnblogs.com/alexme/p/11361563.html https://blog.csdn.net/qq_43348528/article/details/108638030 import cv2 as cv import numpy as np import matplotlib.pyplot as plt from skimage import exposure from skimage.feature i…
阅读更多...
靶场溯源第二题

靶场溯源第二题

关卡描述&#xff1a;1. 网站后台登陆地址是多少&#xff1f;&#xff08;相对路径&#xff09; 首先这种确定的网站访问的都是http或者https协议&#xff0c;搜索http看看。关于http的就这两个信息&#xff0c;然后172.16.60.199出现最多&#xff0c;先过滤这个ip看看 这个很…
阅读更多...
SSM - Springboot - MyBatis-Plus 全栈体系（八）

SSM - Springboot - MyBatis-Plus 全栈体系（八）

第二章 SpringFramework 四、SpringIoC 实践和应用 4. 基于 配置类 方式管理 Bean 4.4 实验三&#xff1a;高级特性&#xff1a;Bean 注解细节 4.4.1 Bean 生成 BeanName 问题 Bean 注解源码&#xff1a; public interface Bean {//前两个注解可以指定Bean的标识AliasFor…
阅读更多...
Mendeley在linux中无法打开APPimage

Mendeley在linux中无法打开APPimage

原因:FUSE 库为用户空间程序提供了一个接口&#xff0c;可以将虚拟文件系统导出到 Linux 内核。由于缺少这个关键库&#xff0c;AppImage 无法按预期工作。 1 安装fuse,打开终端,输入命令 sudo apt install libfuse2 输入用户密码结,果如下 2 确保APPimage作为程序运行 右击…
阅读更多...
docker 获取Nvidia 镜像 | cuda |cudnn

docker 获取Nvidia 镜像 | cuda |cudnn

本文分享如何使用docker获取Nvidia 镜像&#xff0c;包括cuda10、cuda11等不同版本&#xff0c;cudnn7、cudnn8等&#xff0c;快速搭建深度学习环境。 1、来到docker hub官网&#xff0c;查看有那些Nvidia 镜像 https://hub.docker.com/r/nvidia/cuda/tags?page2&name11.…
阅读更多...
【计算机视觉 | 图像模型】常见的计算机视觉 image model（CNNs Transformers） 的介绍合集（五）

【计算机视觉 | 图像模型】常见的计算机视觉 image model（CNNs Transformers） 的介绍合集（五）

文章目录 一、MoCo v3二、AmoebaNet三、Residual Multi-Layer Perceptrons四、FractalNet五、LV-ViT六、RepVGG七、Transformer in Transformer八、SimpleNet九、SpineNet十、Bottleneck Transformer十一、ZFNet十二、DetNet十三、Invertible Rescaling Network十四、SNet十五、…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023