【C++】——list 容器的解析与极致实现

人的一切痛苦，本质上都是对自己的无能的愤怒。

—— 王小波

目录

1、list 介绍

2、list的使用

2.1 list 的构造

2.2 iterator 的使用

2.3 list 的修改

2.4一些特殊接口

2.5 迭代器失效问题

3、实现list

3.1底层结构

结点类

list类

迭代器类

3.2功能接口

迭代器接口

插入删除

拷贝赋值析构函数

4、list与vector 区别对比

1、list 介绍

List是C++标准模板库(STL)中的一个成员，其本质为带头双向循环链表。不同于连续的、紧密排列的数组容器Vector，List容器的内部是由双向链表构成的，使得它在插入和删除操作上，就如同行云流水一般顺畅，不需移动其它元素。

List的结构示意图如下：环状链表的尾是一个空节点，符合“左闭右开”区间。

List适合的场景是那些需要频繁进行插入和删除操作的场合。
例如，如果你正在管理一个动态变化的列表，如任务调度、人员排队等场景，List的特性将大放异彩。但是如果你的应用场景更多地需要随机访问元素，那么Vector或者数组可能是更佳的选择。因为List的顺序访问性能相比之下会显得有些力不从心。

  • 所以如果需要频繁随机的访问数据，那么选择vector容器
  • 如果需要频繁插入删除数据，那么选择list容器
  • 排序不要选择list ！！！可以先拷贝给vector排序后再拷贝回来

迭代器的介绍

迭代器可以按照功能、性质两大模块分类

迭代器的一些性质（重载的运算符）决定着算法库里对算法的调用

而这些迭代器是子类与父类的继承关系

2、list的使用

list 中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口。

2.1 list 的构造

void TestList1()
{list<int> l1;                         // 构造空的l1list<int> l2(4, 100);                 // l2中放4个值为100的元素list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end()）左闭右开的区间构造l3list<int> l4(l3);                    // 用l3拷贝构造l4// 以数组为迭代器区间构造l5int array[] = { 16,2,77,29 };list<int> l5(array, array + sizeof(array) / sizeof(int));// 列表格式初始化C++11list<int> l6{ 1,2,3,4,5 };list<int> l7 = { 1,2,4,5,6,7,8 };// 用迭代器方式打印l5中的元素list<int>::iterator it = l5.begin();while (it != l5.end()){cout << *it << " ";++it;}cout << endl;// C++11范围for的方式遍历for (auto& e : l5)cout << e << " ";cout << endl;
}

2.2 iterator 的使用

关于 list 的迭代器可以姑且理解为指针，本质是通过运算符重载模拟指针的行为

【TIP】

  1.  begin 与 end 为正向迭代器，对迭代器执行++操作，迭代器向后移动
  2. rbegin(end) 与 rend(begin) 为反向迭代器，对迭代器执行++操作，迭代器向前移动
void PrintList(const list<int>& l)
{// 注意这里调用的是list的 begin() const，返回list的const_iterator对象for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it){cout << *it << " ";// *it = 10; 编译不通过}cout << endl;
}void TestList2()
{int array[] = { 1, 2, 3, 4, 5, 6, };list<int> l(array, array + sizeof(array) / sizeof(array[0]));// 使用正向迭代器正向list中的元素// list<int>::iterator it = l.begin();   // C++98中语法auto it = l.begin();                     // C++11之后推荐写法while (it != l.end()){cout << *it << " ";++it;}cout << endl;// 使用反向迭代器逆向打印list中的元素// list<int>::reverse_iterator rit = l.rbegin();auto rit = l.rbegin();while (rit != l.rend()){cout << *rit << " ";++rit;}cout << endl;//迭代器不支持 因为 list 迭代器是双向 不支持 + -/*l.insert(l.begin() + 3);*///想要实现第三个位置后插入一个数可以通过下面代码it = l.begin();int k = 3;while (k--){it++;//支持++}l.insert(it, 40);PrintList(l);}

2.3 list 的修改

struct A {
public:A(int a1 = 1, int a2 = 1):_a1(a1), _a2(a2){cout << "A(int a1=1,int a2=1)" << endl;}A(const A& aa):_a1(aa._a1), _a2(aa._a2){cout << "A(const A& aa)" << endl;}
private:int _a1;int _a2;
};void TestList3()
{int array[] = { 1, 2, 3 };list<int> L(array, array + sizeof(array) / sizeof(array[0]));// 在list的尾部插入4，头部插入0L.push_back(4);L.push_front(0);PrintList(L);// 删除list尾部节点和头部节点L.pop_back();L.pop_front();PrintList(L);list<A>lt;A aa1(1, 1);lt.push_back(aa1);//有名对象尾插lt.push_back(A(2, 2));//匿名对象尾插//lt.push_back(3, 3);//不支持 push back只支持一个参数lt.emplace_back(aa1);lt.emplace_back(A(2, 2));cout << endl;// 前面的插入都是 构造+拷贝构造// (3,3)的插入 并没有拷贝构造 性能上来说优于 push backlt.emplace_back(3, 3);//支持 本质支持直接传构造A对象的参数
}

可以看到 emplace_back 可以支持直接传构造A的参数 省去了临时变量的拷贝构造

插入与删除

// insert /erase 
void TestList4()
{int array1[] = { 1, 2, 3 };list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));// 获取链表中第二个节点auto pos = ++L.begin(); //pos 可以理解为下标cout << *pos << endl;// 在pos前插入值为4的元素L.insert(pos, 4);PrintList(L);// 在pos前插入6个值为5的元素L.insert(pos, 6, 5);PrintList(L);// 在pos前插入[v.begin(), v.end)区间中的元素vector<int> v{ 7, 8, 9 };L.insert(pos, v.begin(), v.end());PrintList(L);// 删除pos位置上的元素L.erase(pos);PrintList(L);// 删除list中[begin, end)区间中的元素，即删除list中的所有元素L.erase(L.begin(), L.end());PrintList(L);
}


// resize/swap/clear
void TestList5()
{// 用数组来构造listint array1[] = { 1, 2, 3 };list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));PrintList(l1);// 交换l1和l2中的元素list<int> l2;l1.swap(l2);PrintList(l1);PrintList(l2);// 将l2中的元素清空l2.clear();cout << l2.size() << endl;
}

2.4一些特殊接口

reverse 逆置链表 sort 排序 （算法库里没有list的排序（迭代器不匹配））

void test_list4()//容器的 逆置与排序
{list<int>lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);print_list(lt);lt.reverse();print_list(lt);reverse(lt.begin(), lt.end());print_list(lt);reverse(++lt.begin(), --lt.end());print_list(lt);//算法库里的排序和容器的排序都是默认升序lt.sort();print_list(lt);//想要降序 则需要 仿函数//less<int>ls;//升序//greater<int>gt;//降序//还可以结合匿名对象使用lt.sort(greater<int>());print_list(lt);
}

merge 合并 与 unique 去重（前提均有序链表）

void test_list5() // merge有序list合并  unique 有序list去除重复数据 
{std::list<double> first, second;first.push_back(3.1);first.push_back(2.2);first.push_back(2.9);second.push_back(3.7);second.push_back(7.1);second.push_back(1.4);first.sort();second.sort();//将 second和first合并 second置为空 前提两list有序first.merge(second);print_list(first); print_list(second);list<int>lt;lt.push_back(1);lt.push_back(2);lt.push_back(2);lt.push_back(3);lt.push_back(3);lt.push_back(4);lt.push_back(1);lt.push_back(1);print_list(lt);lt.sort();//有序的数据去掉重复的数据lt.unique();print_list(lt);
}

剪切拼接 splice 的妙用

void test_list6()
{//把一个链表结点转移给另一个链表std::list<int> mylist1, mylist2;std::list<int>::iterator it;// set some initial values:for (int i = 1; i <= 4; ++i)mylist1.push_back(i);      // mylist1: 1 2 3 4for (int i = 1; i <= 3; ++i)mylist2.push_back(i * 10);   // mylist2: 10 20 30it = mylist1.begin();++it;                         // points to 2mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4// mylist2 (empty)// "it" still points to 2 (the 5th element)print_list(mylist1);print_list(mylist2);// splice 剪切功能//splice 还可以调整当前list的顺序list<int>lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);print_list(lt);int x = 0;cin >> x;it = find(lt.begin(), lt.end(), x);if (it != lt.end()){// 调整当前链表的元素顺序  将 it指向元素 调整到 beginlt.splice(lt.begin(), lt, it);// //迭代器区间//lt.splice(lt.begin(), lt, it,lt.end());}print_list(lt);
}

2.5 迭代器失效问题

前面说过，此处可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。

因为list的底层结构为带头结点的双向循环链表，因此在 list 中进行插入时是不会导致 list 的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

这在 vector 是不成立的，因为 vector 的插入操作有元素移动可能导致重新配置空间，导致原有的迭代器全部失效。

void TestListIterator1()
{int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };list<int> l(array, array + sizeof(array) / sizeof(array[0]));auto it = l.begin();while (it != l.end()){// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值l.erase(it);++it;}
}

VS2022 对于迭代器失效有着严格的监控机制直接报错

// 改正void TestListIterator()
{int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };list<int> l(array, array + sizeof(array) / sizeof(array[0]));auto it = l.begin();while (it != l.end()){l.erase(it++);   //it = l.erase(it); erase 返回下一个位置的迭代器}
}

这里的 erase 会返回下一个结点的位置

对于 erase(it++); 可以理解为 先it++了再执行erase 代码块里的内容

3、实现list

list 容器的底层是一个带头双向循环链表

  • 双向链表的意思是：每个节点不仅存储着数据，还包含两个指针，分别指向前一个节点和后一个节点。这使得 list 可以在常数时间内进行双向遍历和插入、删除操作。

  • 库里的节点结构大致如下：

  •  
     
  •  
    头节点和尾节点会分别指向 nullptr ，这表明链表的边界。
     
 

这种双向链表的结构给予了 list 灵动的特性：它能够轻松地在任意位置增加或移除元素，而这种操作几乎是与容器大小无关的，体现了时间复杂度上的优势。但这种优势的代价是，与数组相比，List在访问元素时的速度会较慢，因为它需要从头开始遍历。这也决定了list的更适合频繁插入的动态数据。
 

3.1底层结构
 

根据对链表的理解，我们需要封装一个结点类，为了兼容迭代器的使用，我们需要对结点指针封装一下即迭代器，最后就是实现功能函数的list 类了，我们可以加入一个头结点方便插入删除和兼容容器的左闭右开。
 

 

结点类
 

// 结点结构体
template<class T>
struct list_node //默认公有 struct
{T _data;list_node<T>* _prev;list_node<T>* _next;list_node(const T& data=T()):_data(data),_prev(nullptr),_next(nullptr){}~list_node(){_next = nullptr;_prev = nullptr;}
};
 

结点类的结构还是很简单的 结构体里包含着数据和前后指针即可，因为要多次访问结点所以设置为 struct 较合适
 

list类
 

构造函数需要创建一个头结点，因为我们要创建双向循环链表，所以头尾都要指向头结点本身。 _size统计元素个数。
 

template<class T>
class list
{typedef list_node<T> Node;public:typedef list_iterator<T, T&, T*> iterator;typedef list_iterator<T, const T&, const T*> const_iterator;void empty_init(){//_head = new Node;//这里写了 Node 带参数构造 所以报错 需要匿名参数_head = new Node(T());_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}list(initializer_list<T>il){empty_init();for (auto& e : il){push_back(e);}_size = il.size();}private:Node* _head;size_t _size;
};
 

这里的 list(initializer_list<T>il) 是C++11出现的语法，就可以像数组一样进行初始化了
 

迭代器类
 

list的迭代器显然不是指针！！ 链表的物理地址并不是连续存储的，指针的++ -- 操作是没有意义的，所以我们需要实现一个用结点指针封装的迭代器类，通过运算符重载去模拟指针的行为
 

 

可以看到库里所实现的迭代器类与我们所预想的一致！
 

如何实现++ 到下一个结点呢？？
 

通过 重载 ++运算符 获取地址返回下一个结点即可
 

迭代器实现：
 

 
 
由于STL list是一个双向链表，迭代器必须具备迁移，后移的能力，所以 list 提供的是 Birdirectional Iterator（双向）
 
List 的迭代器
 
迭代器有两种实现方式，具体应根据容器底层数据结构实现：
 
1. 原生态指针，比如：vector
 
2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
 
（1）指针可以解引用，迭代器的类中必须重载 operator*()
 
（2）指针可以通过->访问其所指空间成员，迭代器类中必须重载 oprator->()
 
（3）指针可以++向后移动，迭代器类中必须重载 operator++() 与 operator++(int)
 
至于 operator--() / operator--(int) 是否需要重载，根据具体的结构来抉择，双向链表可以向前移动，所以需要重载，如果是forward_list（单向）就不需要重载--
 
（4）迭代器需要进行是否相等的比较，因此还需要重载 operator==() 与 operator!=()
 

 

	template<class T>struct list_iterator{typedef list_node<T> Node;typedef list_iterator<T> Self;Node* _node;//指针成员变量list_iterator(Node* node):_node(node){}T& operator*(){return _node->_data;}T* operator->(){return &(_node->_data);}//操作符重载 前置++ 与 后置++的区别是参数是否带（int）// ++it Self& operator++(){_node = _node->_next;return *this;}// it++Self& operator++(int x){Self tmp(*this);//浅拷贝_node = _node->_next;return tmp;}//--itSelf& operator--(){_node = _node->_prev;return *this;}//it--Self& operator--(int x){Self tmp(*this);_node = _node->_prev;return tmp;}bool operator!=(const Self& s)const { return _node != s._node; }bool operator==(const Self& s)const { return _node == s._node; }};
 

有必要注意的是 重载 -> 是为了适配T为自定义类型的情况
 


list<AA>lta;
lta.push_back(AA());
lta.push_back(AA());
lta.push_back(AA());
lta.push_back(AA());
auto ita = lta.begin();
while (ita != lta.end())
{//cout << *ita << ' '; //编译不通过 结构体并没有重载流插入//cout << (*ita)._a1	 << ' '; //cout << ita->_a1 << ' '; //为了可读性省去了一个箭头cout << ita.operator->()->_a1 << ' ';++ita;
}
 

 

调用了 operator ->后 AA* 结构体指针再用->调用了_a1
 

 

这样迭代器大致实现了应该有的功能，我们还需要实现一个const 迭代器，如何封装const 迭代器呢？不能修改内容，只需要重载的 * 和 -> 返回类型加上const 修饰即可
 

但是注意到其他重载的运算符都是一样的，如果重新定义一个const 迭代器是否过于冗余呢？
 

观察一下STL库里是如何实现的
 

 

显然并不是冗余的复制一份迭代器，而是同一个类模板实现的，实例化两个不同的类，本质上与冗余的写法是一个道理
 

 

那么我们开始优化一下迭代器
 

将类模板修改一下
 

//reference 引用  pointer 指针
template<class T , class Ref ,class Ptr>
 

有差异的返回值也改变一下
 

Ref operator*() //现在返回const类型还是普通类型是通过编译器推导的
{return _node->_data;
}Ptr operator->()
{return &(_node->_data);
}
 

那么类实例化的时候传入对应参数编译器就会推导出对应的类：
 

typedef list_iterator<T,T&,T*> iterator;
typedef list_iterator<T,const T&,const T*> const_iterator;
 

测试一下
 

 

那么就实现成功迭代器类模板
 

3.2功能接口
 

迭代器接口
 

iterator begin()//第一个结点指针
{//iterator it(_head->_next);//构造函数//return it; 优化一下return _head->_next; //走的隐式类型转换
}// const 修饰begin 可以兼容拷贝构造 否则出现权限放大 这是不允许的
const_iterator begin()const //前面的const 迭代器是指向元素或引用不可以改变内容 后面的const是修饰this 对象不可以改变
{							//  隐含的this指针由 list * const this 变为 const list* const this 前者是指针不可以更改指向return _head->_next;
}const_iterator cbegin()const
{return _head->_next;
}iterator end()
{return _head; // 头节点 左闭右开
}const_iterator end()const
{return _head;
}const_iterator cend()const
{return _head;
}
 

const 修饰begin 是为了防止权限放大的错误出现
 

 

因为拷贝构造中参数是 const 对象
 

插入删除
 

由于双向循环，插入删除相对比较简单，就是注意链接的顺序性即可
 

void push_back(const T& x)
{//Node* newnode = new Node(x); //没有写Node 构造报错//_head->_prev->_next = newnode;//newnode->_next = _head;//newnode->_prev = _head->_prev;//_head->_prev = newnode;//++_size;insert(end(), x);//复用 insert
}void push_front(const T& x)
{insert(begin(), x);
}iterator insert(iterator pos, const T& x)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);// prev newnode curnewnode->_next = cur;cur->_prev = newnode;newnode->_prev = prev;prev->_next = newnode;++_size;return newnode;
}
 

实现了 insert 我们可以根据迭代器复用 insert 实现尾插和头插
 

TIp：新节点将位于插入点的前一个位置这是STL对于“插入操作”的标准规范。
 

 

删除操作，与 insert 一样使用指针操作，来达到删除的效果。注意要对删除的节点进行释放空间操作（delete），不然会发生内存泄漏！！！
 

void pop_back()
{erase(--end());
}
void pop_front()
{erase(begin());
}
iterator erase(iterator pos) //防止迭代器失效问题
{assert(pos != end());//不可以删除头结点Node* prev = pos._node->_prev;;Node* next = pos._node->_next;prev->_next = next;next->_prev = prev;delete pos._node;--_size;return next;
}

 

需要注意的是，任意位置删除因为使用了迭代器，删除后会造成迭代器失效，所以需要更新迭代器，返回被删除节点的下一个节点的迭代器即可。
 

拷贝赋值析构函数
 

//lt1(lt)
list( const list<T>& lt)
{empty_init();for (auto& e : lt){push_back(e);}
}void swap(list<T>& lt)
{std::swap(_head, lt._head);std::swap(_size, lt._size);}//lt1=lt3
list<T>& operator=(list<T> lt)
{swap(lt);return *this;
}~list()
{clear();delete _head;_head = nullptr;}void clear()
{auto it = begin();while (it!=end()){//erase(it++);//可以这样写 可以理解为 先进行了 it++后再 执行 erase 代码块里的内容it=erase(it);}_size = 0;
}
 

拷贝构造我们只需要范围 for 遍历依次尾插即可，这里空初始化是为了创捷头结点，赋值重载只需要交换头节点就可以
 

4、list与vector 区别对比
 

vector 与 list 都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：
 












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


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











相关文章










MYSQL-SQL-04-DCL（Data Control Language，数据控制语言）








MYSQL-SQL-04-DCL（Data Control Language，数据控制语言）




DCL&#xff08;数据控制语言&#xff09; 
DCL英文全称是Data Control Language(数据控制语言)&#xff0c;用来管理数据库用户、控制数据库的访问权限。 
一、管理用户 
1、查询用户 
在MySQL数据库管理系统中&#xff0c;mysql 是一个特殊的系统数据库名称&#xff0c;它并不…




阅读更多...

















信息安全工程师（54）网络安全审计主要产品与技术指标








信息安全工程师（54）网络安全审计主要产品与技术指标




前言 网络安全审计是对网络系统进行全面的安全评估和检查&#xff0c;以发现网络安全漏洞和威胁&#xff0c;并采取相应的措施进行修补和防护的重要过程。 一、网络安全审计主要产品 域智盾 简介&#xff1a;一款企业级功能强大的网络监控和审计工具&#xff0c;能够持续监控网…




阅读更多...

















ElasticSearch分片








ElasticSearch分片




本文内容参考了田雪松老师编著的《Elastic Stack应用宝典》 
ElasticSearch作为一个搜索引擎&#xff0c;会存储海量的数据。而存储海量的数据&#xff0c;就要解决如何存储的问题&#xff0c;并且保证数据不会丢失&#xff0c;同时还需要保证数据检索的效率&#xff0c;尽可能…




阅读更多...

















【Linux】总线-设备-驱动模型








【Linux】总线-设备-驱动模型




背景 
前面&#xff0c;我们介绍了写驱动代码的一些常规步骤&#xff0c;并且也写了最基本的驱动代码&#xff0c;但是那些代码存在着问题&#xff0c;我们将硬件的信息都写进了驱动里了&#xff0c;如果我们在杂项设备驱动中控制led&#xff0c;那么会在硬件操作接口中包含硬件…




阅读更多...

















WPF+MVVM案例实战-设备状态LED灯变化实现








WPF+MVVM案例实战-设备状态LED灯变化实现




文章目录 1、项目创建2、UI界面布局1. MainWindow.xaml2、颜色转换器实现2.MainViewModel.cs 代码实现 3、运行效果4.源代码下载 1、项目创建 
打开 VS2022 &#xff0c;新建项目 Wpf_Examples&#xff0c;创建各层级文件夹&#xff0c;安装 CommunityToolkit.Mvvm 和 Microsof…




阅读更多...

















STMicroelectronics 意法半导体芯片选型表








STMicroelectronics 意法半导体芯片选型表




意法半导体作为全球知名的半导体厂商&#xff0c;其产品广泛应用于各个领域&#xff0c;从消费电子到工业控制&#xff0c;从汽车电子到通信设备&#xff0c;都能看到意法半导体芯片的身影。在电子硬件设计领域&#xff0c;芯片的选型至关重要。亿配芯城&#xff08;ICgoodFind…




阅读更多...

















（3） c++基本代码








（3） c++基本代码




main函数 main函数只有可执行程序才需要&#xff0c;如果是动态库等则无需main函数。 main函数标准的写法是 
#include <iostream>
using namspace std;
int main(void)
{// 业务代码return 0;
} 当然以上代码只是最简单的案例&#xff0c;其中代表main函数值是int&#…




阅读更多...

















网络编程（21）——通过beast库快速实现http服务器








网络编程（21）——通过beast库快速实现http服务器




目录 
二十一、day21 
1. 头文件和作用域重命名 
2. reponse时调用的一些函数 
3. http_connection 
a. 构造函数 
b. start() 
c. process_request() 
d. create_response() 
e. create_post_response() 
f. write_response() 
4. Server 
5. 主函数 
6. 测试 
1&#xff09;测…




阅读更多...

















参加了十多个面试，一个offer也没拿到...为什么？








参加了十多个面试，一个offer也没拿到...为什么？




前几天&#xff0c;一个小伙伴留言说&#xff1a;自己面试了10多家企业了&#xff0c;愣是没有拿到一个offer&#xff0c;究竟是哪里出了问题&#xff1f; 
这两天笔者抽空整理好了答案&#xff0c;借这位同学的问题&#xff0c;给大家做一个简单的剖析&#xff1a;为什么参加了…




阅读更多...

















【Blender】 学习笔记（一）








【Blender】 学习笔记（一）




文章目录 参考概念原点 Origin游标 轴心点坐标操作默认快捷键两个比较好用的功能渲染器元素不可选&#xff08;防止误选&#xff09; 参考 
参考b站视频&#xff1a;【Kurt】Blender零基础入门教程 | Blender中文区新手必刷教程(已完结) 概念 
模型、灯光、摄像机 
原点 Origin…




阅读更多...

















ArcGIS无插件加载（无偏移）在线天地图高清影像与街道地图指南








ArcGIS无插件加载（无偏移）在线天地图高清影像与街道地图指南




在地理信息系统&#xff08;GIS&#xff09;的应用中&#xff0c;加载高清影像与街道地图对于地图制图、影像查阅、空间数据分析等工作至关重要。天地图作为官方出品的地图服务&#xff0c;以其标准的数据、较快的影像更新速度等特点受到广泛欢迎。以下是如何在ArcGIS中无插件加…




阅读更多...

















《计算机视觉》—— 基于 dlib 库的方法将两张人脸图片进行换脸








《计算机视觉》—— 基于 dlib 库的方法将两张人脸图片进行换脸




声明&#xff1a;此篇文章所用的明星照片只为用于演示代码的效果&#xff0c;无诋毁她人肖像之意 
一、案例实现的思想 此案例的核心是基于人脸68个关键点检测模型来实现的&#xff0c;人脸68个关键带点检测后的效果如下&#xff1a;   通过对上图中红色区域的转换&#xff0c;…




阅读更多...

















Android 图片相识度比较(pHash)








Android 图片相识度比较(pHash)




概述 
在 Android 中&#xff0c;要比对两张 Bitmap 图片的相似度&#xff0c;常见的方法有基于像素差异、直方图比较、或者使用一些更高级的算法如 SSIM&#xff08;结构相似性&#xff09;和感知哈希&#xff08;pHash&#xff09;。 
1. 基于像素的差异比较 
可以逐像素比较…




阅读更多...

















SQL实战测试








SQL实战测试




SQL实战测试 &#xff08;请写下 SQL 查询语句&#xff0c;不需要展示结果&#xff09; 
表 a 
DateSalesCustomerRevenue2019/1/1张三A102019/1/5张三A18 
1. **用一条 ** SQL 语句写出每个月&#xff0c;每个销售有多少个客户收入多少 
输出结果表头为“月”&#xff0c;“销…




阅读更多...

















【LeetCode:910. 最小差值 II + 模拟 + 思维】








【LeetCode:910. 最小差值 II + 模拟 + 思维】




&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…




阅读更多...

















iOS 本地存储地址(位置)








iOS 本地存储地址(位置)




使用UserDefaults存储,数据的位置在沙盒的 Library文件下的 Preferences 里 //获取沙盒地址print("sanbox地址:",NSHomeDirectory())UserDefaults.standard.setValue("4", forKey: "tag4") 存储位置: 打开这个文件: 注意,存入到plist 文件的类型…




阅读更多...

















动态规划-子序列问题——300.最长递增子序列








动态规划-子序列问题——300.最长递增子序列




1.题目解析 题目来源&#xff1a;300.最长递增子序列——力扣 测试用例 2.算法原理 1.状态表示 
首先创建一个与数组大小相同的dp表&#xff0c;此时dp[i]表示的是&#xff1a;以第i个位置为结尾的所有子序列中最长递增子序列的长度 
2.状态转移方程 
此时第i个位置一定是最长递…




阅读更多...

















SpringBoot中yml文件多环境配置








SpringBoot中yml文件多环境配置




yml文件多环境配置步骤如下&#xff1a; 
1、在application.yml同级目录下创建配置文件&#xff0c;格式为&#xff1a; application-环境名.yml&#xff0c;示例如下&#xff1a; 2、通过主配置文件application.yml中的spring.profiles.activexxx指定具体的环境。 
建议配置&a…




阅读更多...

















Chrome谷歌浏览器加载ActiveX控件之JT2Go控件








Chrome谷歌浏览器加载ActiveX控件之JT2Go控件




背景 JT2Go是一款西门子公司出品的三维图形轻量化预览解决工具&#xff0c;包含精确3D测量、基本3D剖面、PMI显示和改进的选项过滤器等强大的功能。JT2Go控件是一个标准的ActiveX控件&#xff0c;曾经主要在IE浏览器使用&#xff0c;由于微软禁用IE浏览器&#xff0c;导致JT2Go…




阅读更多...

















股票与基金资料收集








股票与基金资料收集




声明&#xff1a;本内容是网上资料的收集与整理而成&#xff0c;不定时更新。仅供参考&#xff0c;不构成任何投资建议。 
目录&#xff1a; 
一、股票 
1、黄金交叉和死亡交叉 
2、技术指标 
3、T、TR、THR含义 
二、基金 平准基金 一、股票 
1、黄金交叉和死亡交叉 
“黄金交…




阅读更多...


















最新文章












推荐文章


















Copyright @ 2022~2023