C++奇迹之旅：深度解析list的模拟实现

news2024/11/15 4:28:21

请添加图片描述

文章目录

  • 📝前言
  • 🌠list节点
    • 🌉list
  • 🌠迭代器的创建
    • 🌉const迭代器
  • 🌠代码
  • 🚩总结

📝前言

🌠list节点

我们先建立一个列表里的节点类listnode，用来构造list的节点使用：

// 这个宏定义用于禁用编译器的安全警告。
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
using namespace std;

namespace own
{
    // 定义一个模板结构 listnode，代表链表中的节点
    template<typename T>
    struct listnode
    {
        // 指向前一个节点的指针
        listnode<T>* _prev;

        // 指向下一个节点的指针
        listnode<T>* _next;

        // 节点中存储的数据
        T _data;

        // 构造函数，初始化链表节点
        listnode(const T& data = T())
            : _prev(nullptr) // 前一个节点指针初始化为 nullptr
            , _next(nullptr) // 下一个节点指针初始化为 nullptr
            , _data(data)    // 节点中存储的数据初始化为传入的值（或默认值）
        {}
    };
}

🌉list

在这里插入图片描述
list主要框架：

	template<typename T>
	class list
	{
		typedef listnode<T> Node;
	public:
		typedef ListIterator<T> iterator;
		typedef Listconst_Iterator<T> const_Iterator;
		list()
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
		}

		iterator begin()
		{
			//iterator it(head->next);
			//return it
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_Iterator begin() const
		{
			//iterator it(head->next);
			//return it
			return const_Iterator(_head->_next);
		}

		const_Iterator end() const
		{
			return const_Iterator(_head);
		}
	private:
		Node* _head;
	};

begin使用迭代器iterator返回第一个数据，end返回最后一个数据的下一个位置，也就是头结点。

void test_list01()
{
	list<int> first;
	for (int i = 0; i < 4; i++)
	{
		first.push_back(i);
	}

	//ListIterator<int> it = first.begin();
	list<int>::iterator it = first.begin();
	while (it != first.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : first)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述
为了方便使用iterator，需要重新typedef命名：

typedef ListIterator<T> iterator;
typedef Listconst_Iterator<T> const_Iterator;

🌠迭代器的创建

在这里插入图片描述
在这里插入图片描述
我们使用模拟实现vector时，迭代器类型使用的是T*，因为vector底层是数组，地址连续，但是list不能使用T*，因为指针不能直接++，或–；也不能直接使用Node进行++或–，因此Node不符合遍历的行为，需要Listlterator类封装Node*，再通过重载运算符控制他的行为，具体原因也有以下：

  1. 内存布局：

    • 在 vector 中，元素是连续存储在内存中的，因此可以使用指针（如 T*）进行简单的算术运算（如 ++ 和 --）来访问相邻元素。
    • 在 list 中，元素是分散存储的，每个节点通过指针连接到前一个和下一个节点。节点之间的内存地址不连续，因此不能简单地通过指针算术来访问相邻节点。

  2. 迭代器的设计：

    • 对于 vector，迭代器通常是一个指向数组元素的指针（如 T*），可以直接进行指针运算。
    • 对于 list，迭代器需要封装一个指向节点的指针（如 Node*），并提供自定义的 ++ 和 -- 操作符来遍历链表。这是因为在链表中，节点之间的关系是通过指针而不是通过内存地址的连续性来维护的。

  3. 迭代器的有效性：

    • 在链表中，插入和删除操作可能会导致迭代器失效。使用 Node* 作为迭代器类型时，删除节点后，指向该节点的迭代器将变得无效。因此，链表的迭代器需要在操作后返回一个新的有效迭代器（如在 erase 方法中返回下一个节点的迭代器）。
template<typename T>
struct ListIterator
{
	typedef listnode<T> Node;
	typedef ListIterator<T> self;


	Node* _node;

	ListIterator(Node* node)
		:_node(node)
	{}

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node = it._node;
	}

};

我们先实现list的简单构造函数，接下来是迭代器++和–

//++it
self& operator++()
{
	_node = _node->_next;
	return *this;
}

//it++
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;
}

那么迭代器怎么访问数据的两种方法：
对于pos类：

struct Pos
{
	int _row;
	int _col;

	Pos(int row = 0, int col = 0)
		:_row(row)
		,_col(col)
	{}
};

先把数据插入的多种方法：

void test_list2()
{
	list<Pos> lt1;
	A aa1(100,100);
	A aa2 = {100,100};
	lt1.push_back(aa1);
	lt1.push_back(aa2);
	lt1.push_back({100,100})
	lt1.push_back(Pos(100, 100));
}

我们使用其中一种方法插入数据就行：

void test_list2()
{
	list<Pos> lt1;
	lt1.push_back(Pos(100, 100));
	lt1.push_back(Pos(200, 200));
	lt1.push_back(Pos(300, 300));

	list<Pos>::iterator it = lt1.begin();
	while (it != lt1.end())
	{
		cout << (*it)._row << ":" << (*it)._col << endl;
		++it;
	}
	cout << endl;
}

这里数据是struct公有的，解引用得到的可以通过.访问符进行访问

cout << (*it)._row << ":" << (*it)._col << endl;

这里访问方式就是指针解引用用.访问符进行取数据：

A* ptr = &aa1;
(*ptr)._a1;

在这里插入图片描述
第二种：
还有使用->访问：

cout << it->_row << ":" << it->_col << endl;

但是这样需要重载operator->运算符

T* operator->()
{
	return &_node->_data;
}

返回的是_data的地址
在这里插入图片描述
实际上它是有两个->的，第一个是oeprator()->，第二个是->

cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;

这里隐藏了一个箭头，一个是重载，一个是原生指针的访问操作
在你提供的 test_list02 函数中，确实存在一个关于箭头操作符（->）的重载和原生指针访问的混合使用。让我们详细分析一下这个情况。

🌉const迭代器

typedef Listconst_Iterator<const T> const_Iterator;

对于这个cons_itertator直接这样加是不行的，无法编译成功，const不能调用非const成员函数

我们增加const版本的迭代器

typedef Listconst_Iterator<T> const_Iterator;
const_Iterator begin() const
{
	//iterator it(head->next);
	//return it
	return const_Iterator(_head->_next);
}

const_Iterator end() const
{
	return const_Iterator(_head);
}

这里实现const迭代器呢？
第一种：单独实现一个类，修改正常版本的迭代器：

template<typename T>
class Listconst_Iterator
{
	typedef listnode<T> Node;
	typedef Listconst_Iterator<T> self;
public:
	Node* _node;

	Listconst_Iterator(Node* node)
		:_node(node)
	{}

	//++it
	self& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	//it++
	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

	self& operator--()
	{
		_node = _node->_prev;
		return _node;
	}

	self operator--(int)
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}

	const T* operator->()
	{
		return &_node->_data;
	}

	const T& operator*()
	{
		return _node->_data;
	}

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node = it._node;
	}

};

我们目的是不修改指向的值，只需要在这两个函数前面加上const即可：

const T* operator->()
{
    return &_node->_data;
}
const T& operator*()
{
    return _node->_data;
}

在这里插入图片描述
第二种：合并两个迭代器

template<typename T,class ptr,class ref>
struct ListIterator
{
	typedef listnode<T> Node;
	typedef ListIterator<T, ptr, ref> self;


	Node* _node;

	ListIterator(Node* node)
		:_node(node)
	{}

	ptr operator->()
	{
		return &_node->_data;
	}
	ref operator*()
	{
		return _node->_data;
	}

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	bool operator==(const self& it)
	{
		return _node = it._node;
	}

};
  1. 模板定义
template<typename T, class ptr, class ref>
struct ListIterator
  • ListIterator 是一个模板结构体，接受三个模板参数：
    • T：表示链表中存储的数据类型。
    • ptr：表示指向 T 类型的指针类型（通常是 T*）。
    • ref：表示对 T 类型的引用类型（通常是 T&）。
  1. 类型别名
typedef listnode<T> Node;
typedef ListIterator<T, ptr, ref> self;
  • Node 是一个类型别名，表示链表节点的类型，即 listnode<T>。
  • self 是一个类型别名，表示当前迭代器类型 ListIterator<T, ptr, ref>，用于在成员函数中引用自身类型。
ptr operator->()
{
	return &_node->_data;
}
  • 重载了箭头操作符 operator->()，使得可以通过迭代器访问节点中的数据。
  • 返回 _node 指向的节点的 _data 成员的地址，允许使用 it-> 语法来访问数据。
ref operator*()
{
	return _node->_data;
}
  • 重载了解引用操作符 operator*()，使得可以通过迭代器直接访问节点中的数据。
  • 返回 _node 指向的节点的 _data 成员，允许使用 *it 语法来访问数据。

最后我们需要在使用list里重新定义：

	template<typename T>
	class list
	{
		typedef listnode<T> Node;
	public:
		//typedef ListIterator<T> iterator;
		//typedef Listconst_Iterator<T> const_Iterator;
		typedef ListIterator<T, T*, T&> iterator;
		typedef ListIterator<T, const T*, const T&> const_Iterator;

		list()
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
		}
	......
	}

搞定了这些就是插入的删除的一些操作了

insert()
在这里插入图片描述

insert在这里不会出现迭代器失效，我们可以按照库里的写法进行模仿：

//没有iterator失效
iterator insert(iterator pos, const T& x)
{
	Node* cur = pos._node;
	Node* newnode = new Node(x);
	Node* prev = cur->_prev;

	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;

	return iterator(newnode);
}

erase

//erase 后pos失效了，pos指向的节点就被释放了
iterator erase(iterator pos)
{
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* next = cur->_next;

	prev->_next = next;
	next->_prev = prev;

	delete cur;

	return iterator(next);
}

erase()函数完成后，it所指向的节点已被删除，所以it无效，在下一次使用it时，必须先给其赋值erase删除返回的是下一个位置的迭代器

🌠代码

list.h

# define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>

using namespace std;

namespace own
{
	template<typename T>
	struct listnode
	{
		listnode<T>* _prev;
		listnode<T>* _next;

		T _data;

		listnode(const T& data = T())
			:_prev(nullptr)
			, _next(nullptr)
			, _data(data)
		{}
	};

	template<typename T,class ptr,class ref>
	struct ListIterator
	{
		typedef listnode<T> Node;
		typedef ListIterator<T, ptr, ref> self;


		Node* _node;

		ListIterator(Node* node)
			:_node(node)
		{}

		//++it
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		//it++
		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;
		}

		ptr operator->()
		{
			return &_node->_data;
		}

		ref operator*()
		{
			return _node->_data;
		}

		bool operator!=(const self& it)
		{
			return _node != it._node;
		}

		bool operator==(const self& it)
		{
			return _node = it._node;
		}

	};

	//template<typename T>
	//class Listconst_Iterator
	//{
	//	typedef listnode<T> Node;
	//	typedef Listconst_Iterator<T> self;
	//public:
	//	Node* _node;

	//	Listconst_Iterator(Node* node)
	//		:_node(node)
	//	{}

	//	//++it
	//	self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

	//	//it++
	//	self operator++(int)
	//	{
	//		self tmp(*this);
	//		_node = _node->_next;
	//		return tmp;
	//	}

	//	self& operator--()
	//	{
	//		_node = _node->_prev;
	//		return _node;
	//	}

	//	self operator--(int)
	//	{
	//		self tmp(*this);
	//		_node = _node->_prev;
	//		return tmp;
	//	}

	//	const T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	const T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//	bool operator!=(const self& it)
	//	{
	//		return _node != it._node;
	//	}

	//	bool operator==(const self& it)
	//	{
	//		return _node = it._node;
	//	}

	//};

	template<typename T>
	class list
	{
		typedef listnode<T> Node;
	public:
		//typedef ListIterator<T> iterator;
		//typedef Listconst_Iterator<T> const_Iterator;
		typedef ListIterator<T, T*, T&> iterator;
		typedef ListIterator<T, const T*, const T&> const_Iterator;

		list()
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
		}

		iterator begin()
		{
			//iterator it(head->next);
			//return it
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_Iterator begin() const
		{
			//iterator it(head->next);
			//return it
			return const_Iterator(_head->_next);
		}

		const_Iterator end() const
		{
			return const_Iterator(_head);
		}

		void push_back(const T& val = T())
		{
			/*Node* newnode = new Node(val);
			Node* tail = _head->_prev;

			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;*/

			insert(end(), val);
		}

		void pop_back()
		{
			erase(--end());
		}

		void push_front(const T& val = T())
		{
			insert(begin(), val);
		}

		void pop_front()
		{
			erase(begin());
		}

		//没有iterator失效
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;

			return iterator(newnode);
		}

		//erase 后pos失效了，pos指向的节点就被释放了
		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;

			delete cur;

			return iterator(next);
		}

	private:
		Node* _head;
	};


	void test_list01()
	{
		list<int> first;
		for (int i = 0; i < 4; i++)
		{
			first.push_back(i);
		}

		//ListIterator<int> it = first.begin();
		list<int>::iterator it = first.begin();
		while (it != first.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : first)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	struct pos
	{
		int _row;
		int _col;

		pos(int row = 0, int col = 0)
			:_row(row)
			, _col(col)
		{}

	};


	void test_list02()
	{
		list<pos> It1;
		It1.push_back(pos(100, 200));
		It1.push_back(pos(300, 400));
		It1.push_back(pos(500, 600));
		list<pos>::iterator it = It1.begin();
		while (it != It1.end())
		{
			//cout << (*it)._row << ":" << (*it)._col << endl;
			// 为了可读性，省略了一个->
			//cout << it->_row << ":" << it->_col << endl;
			//cout << it->->_row << ":" << it->->_col << endl;
			cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;

			++it;
		}
		cout << endl;
	}

	void Fun(const list<int>& lt)
	{
		list<int>::const_Iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

	}

	void test_list03()
	{
		list<int> It2;
		It2.push_back(1);
		It2.push_back(2);
		It2.push_back(3);
		
		Fun(It2);
	}

	void test_list04()
	{
		list<int> It3;
		It3.push_back(1);
		It3.push_back(2);
		It3.push_back(3);

		It3.insert(It3.begin(), 100);

		It3.push_back(1);
		It3.push_back(2);
		It3.push_back(3);
		It3.erase(++It3.begin());
		list<int>::iterator it = It3.begin();
		while (it != It3.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		It3.pop_back();
		list<int>::iterator it2 = It3.begin();
		while (it2 != It3.end())
		{
			cout << *it2 << " ";
			++it2;
		}
		cout << endl;


		It3.push_front(200);
		list<int>::iterator it3 = It3.begin();
		while (it3 != It3.end())
		{
			cout << *it3 << " ";
			++it3;
		}
		cout << endl;

		It3.pop_front();
		list<int>::iterator it4 = It3.begin();
		while (it4 != It3.end())
		{
			cout << *it4 << " ";
			++it4;
		}
	}
}

🚩总结

请添加图片描述

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

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

相关文章

【知识】对比Share mem/Pin mem/GPU mem之间的传输速度

【知识】对比Share mem/Pin mem/GPU mem之间的传输速度

转载请注明出处&#xff1a;小锋学长生活大爆炸[xfxuezhagn.cn] 如果本文帮助到了你&#xff0c;欢迎[点赞、收藏、关注]哦~ 目录 参考代码 运行结果 参考代码 import torch import time import matplotlib.pyplot as plt# 初始化设备和张量 device torch.device(cuda) dat…
阅读更多...
float 或 double 运算的时候会有精度丢失的风险？

float 或 double 运算的时候会有精度丢失的风险？

《阿里巴巴 Java 开发手册》中提到&#xff1a;“浮点数之间的等值判断&#xff0c;基本数据类型不能用 来比较&#xff0c;包装数据类型不能用 equals 来判断”。“为了避免精度丢失&#xff0c;可以使用 BigDecimal 来进行浮点数的运算”。 浮点数的运算竟然还会有精度丢失…
阅读更多...
当AI遇上制药：加速跑向未来的快车道，还是布满荆棘的征途？

当AI遇上制药：加速跑向未来的快车道，还是布满荆棘的征途？

01 在全球科技领域&#xff0c;AI的崛起无疑掀起了一场变革的风暴&#xff0c;其影响力已渗透至各行各业&#xff0c;促使各领域积极寻求与AI技术的深度融合&#xff0c;以提升效率、创新产品及优化服务。在医疗健康领域&#xff0c;AI与制药的结合自2007年起航&#xff0c;历…
阅读更多...
Servlet 简介+ Cookie和session+过滤器Filter和监听器Listener

Servlet 简介+ Cookie和session+过滤器Filter和监听器Listener

目录 1.Servlet 介绍 1.1 什么是Servlet 1.2 Servlet的使用方法 1.3 Servlet接口的继承结构 2.Servlet的生命周期 2.1 servlet生命周期中重要的方法 3.获得前端提交数据 4.中文乱码的解决方案 5.重定向和转发 5.1 重定向 5.2 转发 6. Request对象 7. Response对象…
阅读更多...
（南京观海微电子）——半导体制程介绍

（南京观海微电子）——半导体制程介绍

半导体的制程&#xff1a; 1. IC 设计&#xff1a; 预先规划芯片的功能&#xff0c;功能包含算术逻辑、记忆功能、 浮点运算、 数据传输&#xff0c;各功能分布在芯片上各区域&#xff0c;并制作所需的电子元件&#xff0c;工程师使用&#xff08;HDL&#xff09;设计电路图&…
阅读更多...
opencv之几何变换

opencv之几何变换

文章目录 1 前言2 线性几何变换的主要类型2.1 平移 (Translation)&#xff1a;2.1.1 定义2.1.2代码 2.2 缩放 (Scaling)&#xff1a;2.2.1 定义2.2.2 代码 2.3 旋转 (Rotation)&#xff1a;2.3.1 定义2.3.2 代码 2.4 仿射变换 (Affine Transformation)&#xff1a;2.4.1 定义2.…
阅读更多...
Git：版本控制的强大工具与全面解析

Git：版本控制的强大工具与全面解析

Git&#xff0c;作为现代软件开发中不可或缺的版本控制工具&#xff0c;凭借其高效、灵活和分布式的特性&#xff0c;赢得了全球开发者的青睐。无论是个人项目还是大型企业级应用&#xff0c;Git 都能够提供强大的版本管理、分支策略、远程协作等功能。本文将从Git的创建与初始…
阅读更多...
【电子数据取证】Android APK静态分析与动态分析

【电子数据取证】Android APK静态分析与动态分析

文章关键词&#xff1a;电子数据取证、手机取证、安卓取证、云取证、APK分析 当前手机用户量增长越来越快&#xff0c;尤其是中国&#xff0c;手机用户量已超10亿&#xff0c;即大约75%的中国人拥有自己的手机。正因为手机越来越智能化&#xff0c;携带也方便&#xff0c;因此…
阅读更多...
算法day08 链表

算法day08 链表

4.链表_哔哩哔哩_bilibili 一、判断链表为回文 暴力方式&#xff1a; 从链表头开始将链表每一个元素值依次放入数组中&#xff0c;按下标比较值。 从链表尾开始将链表一半元素值放入stack栈中&#xff1b;每次弹栈比较 弹出的值和 链表值。 快慢指针&#xff1a; 假设有这样一个…
阅读更多...
python-Flask搭建简易登录界面

python-Flask搭建简易登录界面

使用Flask框架搭建一个简易的登录界面&#xff0c;登录成功获取token数据 1 搭建简易登录界面 代码如下 from flask import Flask, jsonify from flask import request import time, hashlibapp Flask(__name__)login_html <html> <head> <title>Log…
阅读更多...
ROS - Turtle Nest 使用说明

ROS - Turtle Nest 使用说明

系列文章目录 前言 正如乌龟巢是小乌龟的出生地一样&#xff0c;ROS 2 Turtle Nest 也是新 ROS 软件包诞生和发展的地方。 Turtle Nest 为创建新的 ROS 软件包提供了一个简单的图形用户界面&#xff0c;简化了软件包的创建过程。 一、为什么使用 Turtle Nest 而不是 “ros2 pkg…
阅读更多...
STM32CubeMX生成freertos默认设置卡死，卡在HAL_Init不动，裸机运行程序正常跑，解决方法

STM32CubeMX生成freertos默认设置卡死，卡在HAL_Init不动，裸机运行程序正常跑，解决方法

1、简介 最近通过STM32CubeMX生成freertos发现任务不执行&#xff0c;卡在HAL_Init不动&#xff0c;网上找很久不好使&#xff0c;刚开始怀疑硬件问题&#xff0c;但是裸机运行程序正常跑&#xff0c;然后怀疑软件有问题&#xff0c;但是对F1,F3系列都好使&#xff0c;仅仅对F…
阅读更多...
Git版本控制策略：Rebase还是Merge？详解优缺点与适用场景

Git版本控制策略：Rebase还是Merge？详解优缺点与适用场景

在团队合作中&#xff0c;如何高效地管理代码版本和保持主干代码的稳定性&#xff0c;常常是开发团队关注的焦点。在使用Git管理代码的常规操作中&#xff0c;Merge是最常见的操作&#xff0c;此外Rebase也是一种很实用的操作&#xff0c;尤其是我们想要保持更干净的提交历史时…
阅读更多...
habor仓库

habor仓库

1.安装docker 现在打开不了docker官网&#xff0c;本人是在清华下载站下载的 Index of /docker-ce/linux/rhel/9/x86_64/stable/Packages/ | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror 解压docker 错误&#xff1a; 原因&#xff1a;rhel9自带podman和runc&…
阅读更多...
车辆种类检测数据集介绍

车辆种类检测数据集介绍

车辆种类检测数据集 数据集概述 本数据集专为车辆种类检测任务而设计&#xff0c;包含了大量的车辆图像&#xff0c;每张图像均带有详细的车辆种类标注信息。数据集旨在帮助研究人员和开发人员训练高精度的目标检测模型&#xff0c;以应用于车辆识别、交通监控等多个领域。 数…
阅读更多...
使用mysql保存密码

使用mysql保存密码

登录MySQL 这行命令告诉MySQL客户端程序用户root准备登录&#xff0c;-p表示告诉 MySQL 客户端程序提示输入密码。 mysql -u root -p创建数据库 create database wifi; use wifi;create table password(user_password CHAR(8),primary key(user_password));源码 代码编译 …
阅读更多...
《PCI Express体系结构导读》随记 —— 第II篇 第7章 PCIe总线的数据链路层与物理层（2）

《PCI Express体系结构导读》随记 —— 第II篇 第7章 PCIe总线的数据链路层与物理层（2）

接前一篇文章&#xff1a;《PCI Express体系结构导读》随记 —— 第II篇 第7章 PCIe总线的数据链路层与物理层&#xff08;1&#xff09; 7.1 数据链路层的组成结构 数据链路层使用ACK/NAK协议发送和接收TLP&#xff0c;由发送部件和接收部件组成。其中&#xff0c;发送部件由…
阅读更多...
Ubuntu 20.04 上使用 Prometheus 和 Grafana 监控 PHP 8.0

Ubuntu 20.04 上使用 Prometheus 和 Grafana 监控 PHP 8.0

本文方案监听php状态信息是采用php-php-exporter直接通过sock监控php-fpm信息。还可以通过nginx查询php状态信息从而监控&#xff0c;中间需要加上nginx配置。详见本文末尾 查找最新的 php-fpm_exporter 版本 访问 php-fpm_exporter 的 GitHub releases 页面 来查找最新版本。…
阅读更多...
Nginx简单的安全性配置

Nginx简单的安全性配置

文章目录 引言I Nginx简单的安全性配置禁止特定的HTTP方法限制URL长度禁止某些用户代理限制请求速率连接限制禁止访问某些文件类型II 常见的安全规则防御CC攻击User-Agent过滤GET-URL过滤GET-参数过滤POST过滤（sql注入、xss攻击 ）引言 Nginx本身并不具备复杂的防火墙规则定制…
阅读更多...
【电力电子】单相并网逆变器

【电力电子】单相并网逆变器

摘要 单相并网逆变器是一种将直流电转换为单相交流电&#xff0c;并与电网同步输出的装置。它广泛应用于小型可再生能源系统&#xff0c;如光伏发电&#xff0c;确保产生的电能能够高效、安全地并入电网。本文探讨了单相并网逆变器的设计理论、控制策略以及其在不同负载条件下…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023