C++ STL 容器系列(三)list —— 编程世界的万能胶,数据结构中的百变精灵

STL系列学习参考:

C++ STL系列__zwy的博客-CSDN博客icon-default.png?t=O83Ahttps://blog.csdn.net/bite_zwy/category_12838593.html

学习C++ STL的三个境界,会用,明理,能扩展,STL中的所有容器都遵循这个规律,下面我们就按照这三个境界来学习list

一、认识标准库中的list

list的参考文档:

cplusplus.com/reference/list/list/?kw=listicon-default.png?t=O83Ahttps://cplusplus.com/reference/list/list/?kw=list头文件为<list>

list 成员变量

list是C++标准库提供的类模板,本质上是一个双向带头循环链表.

结构如下图所示:

二、list的的常用接口

1、Construct 构造函数

<1>、list()默认构造,构造空的list
list<int>  mylist1;
list<string>  mylist2;
//list中的元素类型为 vector<int>
list<vector<int>> mylist3;

 默认构造的list元素个数都是0.

<2>、 list (size_type n, const value_type& val)
构造的list中包含n个值为val的元素
//使用n个value构造
list<int>  mylist1(10, 5);
list<string>  mylist2(3,"hellolist");
//list中的元素类型为 vector<int>
// 第二个参数是vector的initializer list构造
list<vector<int>> mylist3(5,{1,2,3,4,5});

其中mylist3有5个元素,每个元素是size为5的vector.

<3>、list (const list& x)(重点)

拷贝构造

//使用n个value构造
list<int>  mylist1(10, 5);
list<string>  mylist2(3,"hellolist");
//list中的元素类型为 vector<int>
// 第二个参数是vector的initializer list构造
list<vector<int>> mylist3(5,{1,2,3,4,5});//拷贝构造
list<int> copy1(mylist1);
list<string> copy2(mylist2);
list<vector<int>> copy3(mylist3);

拷贝构造时要注意,拷贝构造对象和被拷贝对象的实例化类型要相同,否则无法构造。

<4>、list (InputIterator first, InputIterator last)

迭代器区间构造

//迭代器区间构造
vector<int> v{ 1,2,3,4,5 };
//利用vector的整个区间构造
list<int> listint(v.begin(), v.end());string s("hellolist");
//使用string的部分区间构造
list<char> listchar(s.begin() + 1, s.end() - 2);//使用vector<vector<int>> 的迭代器区间
vector<vector<int>> vv(10, { 1,3,5,7,9 });
list<vector<int>> listv(vv.begin() + 2, vv.end() - 3);

使用迭代器区间构造,也需要保证类型匹配!

<5>、list的initializer list 构造
//list的initializer list 构造
list<int> list_int{ 1,2,3,4,5 };
list<string> list_str{ "hellolist","string","vector","list" };
//list的initializer list 构造中嵌套了vector的initializer list 构造
list<vector<int>> list_v{ {1,2,3},{3,4,5},{4,5,6} };

list 同样支持C++11提出的initializer list 构造。

2、list iterator(重点)

此处,大家可暂时将迭代器iterator理解成一个指针,该指针指向list中的某个节点。

list的迭代器iterator只支持++和--等自增自减操作,不支持+和-。

<1>、begin()+end()
返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
<2>、rbegin()+rend()
返回第一个元素的 reverse_iterator, end() 位置 返回最后一个元素下一个位 reverse_iterator, begin() 位置
  begin end 为正向迭代器,对迭代器执行 ++ 操作,迭代器向后移动
 rbegin(end) rend(begin) 为反向迭代器,对迭代器执行 ++ 操作,迭代器向前移动
<3>、迭代器遍历
正向迭代器遍历:
list<string> list_s{ "apple","banana","orange","grape","mango","strawberry"};
list<string>::iterator it = list_s.begin();
while (it != list_s.end())
{//迭代器支持解引用cout << *it << endl;++it;
}
反向迭代器遍历:
list<string> list_s{ "apple","banana","orange","grape","mango","strawberry"};
list<string>::reverse_iterator it = list_s.rbegin();
while (it != list_s.rend())
{//迭代器支持解引用cout << *it << endl;++it;
}

3、Capacity 容量

<1>、empty()

检查list是否为空,为空返回true,否则返回false         

list<int> list_int;
if (list_int.empty())cout << "list_int为空" << endl;
elsecout << "list_int不为空" << endl;list<string> list_str{ 2,"hellolist" };
if (list_str.empty())cout << "list_str为空" << endl;
elsecout << "list_str不为空" << endl;

<2>、size()

返回list当前的有效节点个数

list<int> myints{ 1,2,3,4,5 };
cout << "myints size:" << myints.size() << endl;list<char> mychars{ 'a','b','c','d','e','f' };
cout << "mychars size:" << mychars.size() << endl;list<string> mystrs{ "apple","banana","grape","strawberry"};
cout << "mystrs size:" << mystrs.size() << endl;

4、Element access 

list 元素访问

<1>、front()

返回list的第一个节点中值的引用,如果list中的元素被const修饰,那么就返回const 引用.

list<int> myints{ 1,2,3,4,5 };
cout << "myints.front() is: " << myints.front() << endl;myints.front() -= 10;
cout << "Now myints.front() is: " << myints.front() << endl;

<2>、back()

返回list的最后一个节点中值的引用,如果list中的元素被const修饰,那么同样返回const 引用.
list<string> mystrs{ "string","vector","linux","windows"};
cout << "mystrs.back() is: " << mystrs.back() << endl;mystrs.back().append("WINDOWS");
cout << "Now mystrs.back() is: " << mystrs.back() << endl;

<3>、const_reference

返回const引用的情况

const list<int> c_list{ 1,2,3,4,5 };
//list中元素被const修饰,front和back返回const引用不能修改
//c_list.front() += 10;
//c_list.back() -= 10;

5、list modifiers 增删查改

list有关增删查改的接口很多,我们只挑重点的来讲!

<1>、push_front()

在list首元素前插入值为val的元素,即头插

<2>、push_back()

在list尾部插入值为val的元素,即尾插

void Test_listpush()
{vector<int> v{ 1,2,3,4,5 };list<int> mylist(v.begin(), v.end());cout << "插入前:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;mylist.push_front(0);	mylist.push_back(6);cout << "插入后:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;
}

<3>、pop_front()

删除list中第一个元素

<4>、pop_back()

删除list中最后一个元素

void Test_listpop()
{list<char> mylist{ 'a','b','c','d','e' };cout << "删除前:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;mylist.pop_front();	mylist.pop_back();cout << "删除后:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;
}

<5>、insert()

在list position 位置前插入值为val的元素,其中position是一个迭代器

如果成功插入,则返回新插入的第一个元素的迭代器。

void Test_listinsert()
{list<string> mylist{ "Java","C++","PHP","Python","C" };cout << "insert前:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;//在position位置前插入valmylist.insert(mylist.begin(), "bash");//在position位置前 插入 n个valmylist.insert(++mylist.begin(), 3, "C#");//在position位置前 插入一段迭代器区间vector<string> v{ "Go","Rust","SQL" };mylist.insert(mylist.end(), v.begin(), v.end());cout << "insert 后:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;
}

<6>、erase()

删除list position位置的元素,其中position同样是一个迭代器。返回值是一个迭代器,指向被删除元素之后的那个元素。如果被删除的元素是list中的最后一个元素,那么返回end()
 erase的返回值非常重要,有关list的迭代器失效问题 !!!
void Test_erase()
{list<string> mylist{ "Java","C++","PHP","Python","C","bash","Go","Rust","SQL"};cout << "erase前:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;//删除position位置的元素mylist.erase(mylist.begin());mylist.erase(--mylist.end());//删除一段迭代器区间[firsr,last) 左闭右开mylist.erase(++mylist.begin(), --mylist.end());cout << "erase后:" << endl;for (auto e : mylist){cout << e << " ";}cout << endl;
}
<7>、swap

交换两个类型相同的list中的元素
void printlist(list<int> l)
{for (auto e : l){cout << e<< " ";}cout << endl;
}
void Test_swap()
{list<int> list1{ 1,3,5,7,9 };list<int> list2{ 2,4,6,8,10 };cout << "swap前:" << endl;printlist(list1);printlist(list2);list1.swap(list2);cout << "swap后:" << endl;printlist(list1);printlist(list2);
}

<8>、clear

清除list中的所有元素

void Test_clear()
{list<string> list_str{"clear","swap","push_back","insert","erase","pop_front"};cout << "clear前:" << endl;for (auto e : list_str){cout << e << " ";}cout << endl;list_str.clear();cout << "clear后:" << endl;for (auto e : list_str){cout << e << "";}
}

<9>、resize

如果n小于当前list的size,size减少到前n个元素,并删除超出的元素。

如果n大于当前容器的size,则在末尾插入所需的元素,如果指定了val,则将新元素初始化为val的,否则将其进行值初始化。

n<list当前size的情况:

void Test_resize()
{list<int> list_int{ 1,2,3,4,5 };cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}cout << endl;list_int.resize(3);cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}
}

n>list 当前size的情况:

void Test_resize()
{list<int> list_int{ 1,2,3,4,5 };cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}cout << endl;//不给value的情况 初始化默认值list_int.resize(10);cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}
}

void Test_resize()
{list<int> list_int{ 1,2,3,4,5 };cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}cout << endl;//给value,就用value初始化list_int.resize(10,6);cout << "resize前:" << endl;for (auto e : list_int){cout << e << " ";}
}

<10>、emplace系列接口

list 的emplace系列接口涉及到C++11可变参数模板以及右值引用的移动语义问题,在C++11讲解中对emplace的使用及原理做了详细讲解,大家请移步至下面这篇博文:

深入探索C++11 第三弹:C++11完结,迈进高效编程的新纪元-CSDN博客icon-default.png?t=O83Ahttps://blog.csdn.net/bite_zwy/article/details/143832840?spm=1001.2014.3001.5501

三、list的迭代器失效问题(重点)

前面说过,大家可将迭代器暂时理解成类似于指针,迭代器失效即迭代器所指向的节点的无效,即该节点被删除了。因为list的底层结构为带头结点的双向循环链表,因此在list中进行插入时是不会导致list的迭代器失效的,只有在删除时才会失效,并且失效的只是指向被删除节点的迭代器,其他迭代器不会受到影响。
接下来看一个迭代器失效的例子:
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;}
}

erase函数执行后,it 指向的节点被释放,此时 it 已经失效,下面对it++就会导致错误,这就是list的迭代器失效问题!

解决办法:

之前我们说过erase会返回被删除的节点的下一个位置的迭代器,所以我们只需要在使用it前将erase的返回值重新赋值给it即可.

// 改正
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()){it = l.erase(it);}
}

四、list的模拟实现

1、List_Node的实现

// List的节点类
template<class T>
struct ListNode
{ListNode(const T& val = T()): _prev(nullptr), _next(nullptr), _val(val){}ListNode<T>* _prev;ListNode<T>* _next;T _val;
};

2、iterator 和const_iterator的封装

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

template<class T, class Ref, class Ptr>
class ListIterator
{typedef ListNode<T> Node;typedef ListIterator<T, Ref, Ptr> Self;// Ref 和 Ptr 类型需要重定义下,实现反向迭代器时需要用到
public:typedef Ref Ref;typedef Ptr Ptr;
public://// 构造ListIterator(Node* node = nullptr): _node(node){}//// 具有指针类似行为Ref operator*(){return _node->_val;}Ptr operator->(){return &(operator*());}//// 迭代器支持移动Self& operator++(){_node = _node->_next;return *this;}Self operator++(int){Self temp(*this);_node = _node->_next;return temp;}Self& operator--(){_node = _node->_prev;return *this;}Self operator--(int){Self temp(*this);_node = _node->_prev;return temp;}//// 迭代器支持比较bool operator!=(const Self& l)const{return _node != l._node;}bool operator==(const Self& l)const{return _node != l._node;}Node* _node;
};template <class T>
struct list_const_iterator
{typedef List_Node<T> Node;typedef list_const_iterator<T> Self;Node* _node;//list_const_iterator(Node* node):_node(node){}const T& operator*(){return _node->_data;}Self& operator++(){_node = _node->_next;return *this;}const T* operator->(){return &_node->_data;}Self& operator++(int){Self tmp = *this;_node = _node->_next;return tmp;}Self& operator--(){_node = _node->_prev;return *this;}Self& operator--(int){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;}
};

3、 reverse_list_Iierator实现

通过前面例子知道,反向迭代器的++就是正向迭代器的--,反向迭代器的--就是正向迭代器的++,因此反向迭代器的实现可以借助正向迭代器,即:反向迭代器内部可以包含一个正向迭代器,对 正向迭代器的接口进行包装即可。

	template<class Iterator>class ReverseListIterator{// 注意:此处typename的作用是明确告诉编译器,Ref是Iterator类中的一个类型,而不是静态成员变量// 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量// 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的public:typedef typename Iterator::Ref Ref;typedef typename Iterator::Ptr Ptr;typedef ReverseListIterator<Iterator> Self;public://// 构造ReverseListIterator(Iterator it): _it(it){}//// 具有指针类似行为Ref operator*(){Iterator temp(_it);--temp;return *temp;}Ptr operator->(){return &(operator*());}//// 迭代器支持移动Self& operator++(){--_it;return *this;}Self operator++(int){Self temp(*this);--_it;return temp;}Self& operator--(){++_it;return *this;}Self operator--(int){Self temp(*this);++_it;return temp;}//// 迭代器支持比较bool operator!=(const Self& l)const{return _it != l._it;}bool operator==(const Self& l)const{return _it != l._it;}Iterator _it;};

4、list类模板的实现

	template<class T>class list{typedef ListNode<T> Node;public:// 正向迭代器typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T&> const_iterator;// 反向迭代器typedef ReverseListIterator<iterator> reverse_iterator;typedef ReverseListIterator<const_iterator> const_reverse_iterator;public:///// List的构造list(){CreateHead();}list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i)push_back(value);}template <class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}list(const list<T>& l){CreateHead();// 用l中的元素构造临时的temp,然后与当前对象交换list<T> temp(l.begin(), l.end());this->swap(temp);}list<T>& operator=(list<T> l){this->swap(l);return *this;}~list(){clear();delete _head;_head = nullptr;}///// List的迭代器iterator begin(){return iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator begin()const{return const_iterator(_head->_next);}const_iterator end()const{return const_iterator(_head);}reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator rbegin()const{return const_reverse_iterator(end());}const_reverse_iterator rend()const{return const_reverse_iterator(begin());}///// List的容量相关size_t size()const{Node* cur = _head->_next;size_t count = 0;while (cur != _head){count++;cur = cur->_next;}return count;}bool empty()const{return _head->_next == _head;}void resize(size_t newsize, const T& data = T()){size_t oldsize = size();if (newsize <= oldsize){// 有效元素个数减少到newsizewhile (newsize < oldsize){pop_back();oldsize--;}}else{while (oldsize < newsize){push_back(data);oldsize++;}}}// List的元素访问操作// 注意:List不支持operator[]T& front(){return _head->_next->_val;}const T& front()const{return _head->_next->_val;}T& back(){return _head->_prev->_val;}const T& back()const{return _head->_prev->_val;}// List的插入和删除void push_back(const T& val){insert(end(), val);}void pop_back(){erase(--end());}void push_front(const T& val){insert(begin(), val);}void pop_front(){erase(begin());}// 在pos位置前插入值为val的节点iterator insert(iterator pos, const T& val){Node* pNewNode = new Node(val);Node* pCur = pos._node;// 先将新节点插入pNewNode->_prev = pCur->_prev;pNewNode->_next = pCur;pNewNode->_prev->_next = pNewNode;pCur->_prev = pNewNode;return iterator(pNewNode);}// 删除pos位置的节点,返回该节点的下一个位置iterator erase(iterator pos){// 找到待删除的节点Node* pDel = pos._node;Node* pRet = pDel->_next;// 将该节点从链表中拆下来并删除pDel->_prev->_next = pDel->_next;pDel->_next->_prev = pDel->_prev;delete pDel;return iterator(pRet);}void clear(){Node* cur = _head->_next;// 采用头删除删除while (cur != _head){_head->_next = cur->_next;delete cur;cur = _head->_next;}_head->_next = _head->_prev = _head;}void swap(bite::list<T>& l){std::swap(_head, l._head);}private:void CreateHead(){_head = new Node;_head->_prev = _head;_head->_next = _head;}private:Node* _head;};

五、list和vector的对比

std:liststd::vector
底层存储结构
带头结点的双向循环链表。每个元素在内存中不连续存储,通过节点中的指针指向下一个元素。
动态数组结构。元素在内存中是连续存储的。
随机访问不支持高效的随机访问。要访问中间的元素,需要从头部(或尾部)开始遍历链表,时间复杂度为O(N),其中N是到目标元素的距离。支持高效的随机访问。可以通过下标运算符[]直接访问元素,时间复杂度为O(1)。
插入和删除元素在任意位置插入和删除元素效率高。在链表中间插入或删除一个元素,只需要调整指针,时间复杂度为O(1)(不考虑查找插入位置的时间)。在末尾插入元素效率高,时间复杂度一般为(当需要重新分配内存时可能会更复杂)。但是在中间或者开头插入 / 删除元素效率较低,因为需要移动插入 / 删除位置之后的所有元素,平均时间复杂度为O(N)。
内存分配每次插入新元素时,只需分配新节点的内存,不需要重新分配整个容器的内存(除非内存不足)。当元素数量超过当前容量时,需要重新分配一块更大的连续内存空间,并且将原有元素复制到新空间中,这个过程可能比较耗时。
迭代器失效删除操作只会使指向被操作元素的迭代器失效,其他迭代器不受影响。
在插入元素时,要给所有的迭代器重新赋值,因为
插入元素有可能会导致重新扩容,致使原来迭代器
失效,删除时,当前迭代器需要重新赋值否则会失
空间开销

除了存储元素本身,每个节点还需要额外的指针来维护链表结构,所以有一定的空间开销。

没有额外的指针开销,但是可能会因为内存对齐等原因

浪费少量空间。

使用 场景
需要高效存储,支持随机访问,不关心插入删除效率。
大量插入和删除操作,不关心随机访问。

六、小结

list也是STL中很基础同时也很重要的容器,是非常重要的数据结构之一,在操作系统,日志记录等方面都有很重要的应用,值得大家深入学习。

接下来会给大家带来C++ STL中其他容器的深度讲解,创作不易,还请多多互三支持。

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

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

相关文章

UE5 打包环境、C++环境安装说明

文章目录 前言一、安装 Visual Studio 及其必装组件1. 下载安装包1.1 方法11.1 方法22. 安装 Visual Studio3. 修改安装位置(可选)4. 勾选必装组件二、打包错误排查1. 错误:Visual Studio 2022 compiler version 14.42.34433 is not a preferred version. Please use the la…

【AI技术赋能有限元分析应用实践】Abaqus有限元分析到深度学习方法应用全过程——汽车刹车片热力耦合分析

目录 一、项目实现介绍**项目背景****项目目标****项目流程概述****技术融合****项目价值** 二、实现流程**Step 1: 分析问题构建方法&#xff0c;寻找主要分析目标&#xff0c;确定初步目标****Step 2: 使用 Abaqus 完成有限元仿真&#xff0c;后处理并保存数据为 odb 格式***…

从0开始linux(38)——线程(1)线程概念

欢迎来到博主专栏&#xff1a;从0开始linux 博主ID&#xff1a;代码小豪 文章目录 进程与线程线程概念线程的优点线程的独立数据 进程与线程 如果要理解线程&#xff0c;那么进程将会时绕不开的点。首先我们回顾一下我们之前在进程章节当中是如何描述进程的&#xff1f; 进程&…

Vue中的计算属性和监听属性

在Vue中&#xff0c;计算属性和监听属性是两种非常有用的功能&#xff0c;它们可以帮助我们更好地管理数据和响应数据的变化。 计算属性 计算属性是基于它们的依赖进行缓存的。只有当依赖发生变化时&#xff0c;计算属性才会重新计算。这使得计算属性非常适合用于执行昂贵的计…

Doge东哥wordpress主题

Doge东哥wordpress主题是一款专为中小型企业设计的WordPress外贸网站模板&#xff0c;它以其现代、专业且用户友好的界面&#xff0c;为企业提供了一个展示产品和服务的理想平台。以下是对该模板的详细描述&#xff1a; 首页设计概览 首页的设计简洁而不失大气&#xff0c;顶…

keil 5. Flash Timeout. Reset the Target and try it again.

使用官方STM32 ST-LINK Utility 烧写软件 KEIL 5, 设置DFP 包支持FLASH烧写算法 Keil 5, Flash Timeout. Reset the Target and try it again.-CSDN博客

MySQL源码编译

华子目录 下载源码包上传并解压安装cmake环境检测make编译make install安装 部署 下载源码包 下载相应源码包mysql5.7编译安装需要boost库&#xff0c;这里官网下载含boost的源码包https://downloads.mysql.com/archives/community/ 上传并解压 [rootmysql-node1 ~]# du -sh …

【Canvas与化学】枣红实心球钙元素图标

【成图】 120*120 大小图 【代码】 <!DOCTYPE html> <html lang"utf-8"> <meta http-equiv"Content-Type" content"text/html; charsetutf-8"/> <head><title>钙元素图标 Draft2</title><style type&qu…

YOLOv8实战无人机视角目标检测

本文采用YOLOv8作为核心算法框架&#xff0c;结合PyQt5构建用户界面&#xff0c;使用Python3进行开发。YOLOv8以其高效的实时检测能力&#xff0c;在多个目标检测任务中展现出卓越性能。本研究针对无人机目标数据集进行训练和优化&#xff0c;该数据集包含丰富的无人机目标图像…

C#里怎么样使用new修饰符来让类智能选择基类函数还是派生类函数?

C#里怎么样使用new修饰符来让类智能选择基类函数还是派生类函数&#xff1f; 在C#里有一个特殊的用法&#xff0c;就是在创建与基类相同的函数时&#xff0c; 如果使用一个new修饰符&#xff0c;就会导致它会根据变量的类型而选择不同的函数运行。 这是一个比较特殊的使用方法&…

私有库gitea安装

一 gitea是什么 Gitea是一款自助Git服务&#xff0c;简单来说&#xff0c;就是可以一个私有的github。 搭建很容易。 Gitea依赖于Git。 类似Gitea的还有GitHub、Gitee、GitLab等。 以下是安装步骤。 二 安装sqilite 参考&#xff1a; 在windows上安装sqlite 三 安装git…

netconf 代码架构

NETCONF&#xff08;Network Configuration Protocol&#xff09;是一种基于 XML 的网络配置管理协议&#xff0c;主要用于在网络设备之间进行配置管理、状态监控和操作。它被设计为一种可扩展的协议&#xff0c;并且在自动化网络管理中扮演着重要角色。NETCONF 通过安全的通信…

【Anaconda】 创建环境报错:CondaHTTPError: HTTP 000 CONNECTION FAILED for url

问题描述 使用 Anaconda 创建环境时报错&#xff1a; CondaHTTPError: HTTP 000 CONNECTION FAILED for url <https://repo.anaconda.com/pkgs/free/noarch/repodata.json.bz2> Elapsed: -An HTTP error occurred when trying to retrieve this URL. HTTP errors are o…

十一、快速入门go语言之接口和反射

文章目录 接口:one: 接口基础:two: 接口类型断言和空接口:star2: 空接口实现存储不同数据类型的切片/数组:star2: 复制切片到空接口切片:star2: 类型断言 反射 &#x1f4c5; 2024年5月9日 &#x1f4e6; 使用版本为1.21.5 接口 十、Java类的封装和继承、多态 - 七点半的菜市…

计算机的错误计算(一百七十)

摘要 回复一中学生来信&#xff0c;探讨 MATLAB 关于算式 的计算问题。 在计算机的错误计算&#xff08;一百三十二&#xff09;中&#xff0c;我们探讨了手持式计算器关于算式 的计算问题。一中学生来信询问该算式在数学软件中是否会出错。 例1. 在 MATLAB 中计算 . 首…

Maven CMD命令

打包测试命令 在当前文件中 >mvn clean package -D maven.test.skiptrue 基本命令 mvn clean 清理目标目录&#xff08;target&#xff09;中的输出文件。 mvn compile 编译主源代码路径&#xff08;src/main/java&#xff09;下的 Java 代码。 mvn test-compile 编译测试源…

redis升级

服务器原来使用yum安装的。可以参考下面文章 Linux---Redis安装以及配置_yum安装redis-CSDN博客 yum安装的redis版本比较旧&#xff0c;我们直接下载源码编译安装。 我们下载已经发布的版本 Releases redis/redis GitHub 1、解压 2、make 3、make install 4、修改red…

【科研】9如何高效阅读和理解学术论文

【科研】9如何高效阅读和理解学术论文 写在最前面一、为什么需要系统的阅读方法&#xff1f;二、阅读论文的11步方法三、实践示例四、常见问题解答五、结语 &#x1f308;你好呀&#xff01;我是 是Yu欸 &#x1f30c; 2024每日百字篆刻时光&#xff0c;感谢你的陪伴与支持 ~ …

iptables 用于设置、维护和检查 IP 数据包的过滤规则。其基本用法是通过命令行界面配置流量的过滤策略,分为以下几类规则链:INPUT(入站流量)、OU

iptables 是 Linux 下的一个强大的防火墙工具&#xff0c;用于设置、维护和检查 IP 数据包的过滤规则。其基本用法是通过命令行界面配置流量的过滤策略&#xff0c;分为以下几类规则链&#xff1a;INPUT&#xff08;入站流量&#xff09;、OUTPUT&#xff08;出站流量&#xff…

CSS中flex:1时overflow失效

现象&#xff1a; 当连续多层标签使用了flex:1或者height:100%之后&#xff0c;最后一层设置overflow: auto失效 解决办法&#xff1a; 给上面设置了flex:1或者height:100%的标签都添加上overflow: auto