C++ List 容器：实现原理深度解析

news2025/1/21 21:07:02

1.基本结构

1.1list底层

list底层是一个双向链表，每个节点包含三个主要部分：存储的数据，指向前一个节点和后一个节点的指针。我们首先定义一个 list_node 结构体来描述链表节点。

template <class T>
struct list_node {
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;

    list_node(const T& x = T()) 
        : _data(x), _next(nullptr), _prev(nullptr) 
    {}
};

使用类模板定义以便处理不同类型的数据，同时写一个构造函数，将要插入list容器中的数据构造为一个双向指针。

例如我们要往list中插入一个值为value的数据，我们需要动态申请一个节点，而上面的构造函数就会将val构造为一个值为value的双向指针。

typedef list_node<T> Node;
Node* newnode = new Node(val);

1.2 实现迭代器

迭代器是容器的重要组成部分，它允许我们像使用指针一样遍历链表。因为list容器的底层是链表，所以迭代器有些特殊，与vector、list不同，需要特殊实现。
我们定义 list_iterator，用于遍历 list_node。

template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;
	Node* _node;

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

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

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

	//后置
	iterator operator++(int)
	{
		iterator tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	//前置
	iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	iterator& operator--()
	{
		_node = _node->_prev;
		return *this;
	}

	bool operator!=(const iterator& s)
	{
		return _node != s._node;
	}

	bool operator==(const iterator& s)
	{
		return _node == s._node;
	}

};

1.3 实现 list 容器

list 容器的核心实现依赖于双向链表。我们使用 list_node 和 list_iterator 构建 list 的功能。

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;

	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);
	}

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

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}
	void clear(){
		auto it = begin();
		while (it != end())
		{
			it = erase(it);
		}
	}

	iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

	void push_front(const T& x){
		insert(begin(), x);
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}

	iterator erase(iterator pos)
	{
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}

private:
	Node* _head;
};

2. 迭代器剖析

2.1剖析 iterator

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;
	}

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

	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}

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

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

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
};

在上面这段代码中：

typedef list_node<T> Node;
typedef list_iterator<T> Self;
Node* _node;

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

（1）定义了一个_node指针，指向当前迭代器所在的链表节点；接着是一个构造函数，用于初始化迭代器，使其指向当前节点。

例如，调用迭代器的begin（）方法，iterator就会调用lst_iterator结构体的构造函数，将_node初始化为_head->next所指向的节点。

typedef list_iterator<T> iterator;		
iterator begin(){
	return iterator(_head->_next);
}

 （2）迭代器中的“*”解引用操作用来访问当前迭代器所指向的对象，所以我们直接返回该节点的数据来达到预期的效果，并且返回的是一个数据类型T的一个引用，表示我们可以通过*操作符修改数据。

“->”成员访问操作符，在迭代器中我们通常用它来指向节点的数据，即_node->data，因此我们直接返回该节点数据的地址就可以达到期望效果，返回值是一个T类型的指针。这样我们通过->操作符就得到了指向所期望的节点的数据的指针。（指针 就是 地址）

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

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

（3） 前置++和前置--首先是将当前指针指向下一个节点，这里调用了上面我们实现的->操作符，即_node得到了下一个节点的地址，也就是指向了下一个节点。

后置++和后置--先将当前节点保存下来，再修改_node指向，返回临时保存下来的指针。

//前置	
Self& operator++(){
		_node = _node->_next;
		return *this;
	}

	Self& operator--(){
		_node = _node->_prev;
		return *this;
	}
//后置
	Self operator++(int){
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

2.2 iterator与const_iterator的一体实现

上面所实现的代码是可修改的 iterator，如果要实现const_iterator，我们是否还要再写一个结构体呢？虽然可以再写一个结构体来实现const_iterator，但是使用两个结构体来是想这两种迭代器是不是有些太冗余了？我们是否可以通过一个结构体来实现这两种迭代器呢？答案是可以，我们通过设置多个类模板参数就可以达到我们想要的效果。

对类模版不熟悉的小伙伴可以先去下面这篇有关模版的博客中学习

C++泛型编程：模版-CSDN博客

这里提一嘴：如果我们要实现方法都是公有的，通常用struct，如果有私有的则用class

一个结构体实现两种迭代器代码如下：

template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;
	Node* _node;

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

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

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

	//后置
	iterator operator++(int)
	{
		iterator tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	//前置
	iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	iterator& operator--()
	{
		_node = _node->_prev;
		return *this;
	}

	bool operator!=(const iterator& s)
	{
		return _node != s._node;
	}

	bool operator==(const iterator& s)
	{
		return _node == s._node;
	}

};

这段代码与iterator的不同之处仅在于模版参数，因为iterator和const_iterator最大的区别就是前者可以修改容器中的元素，而后者不能修改容器中的元素。它们的解引用操作和成员访问操作不同，而++、--等操作相同。因此只需要改变*、->两种操作。

使用iterator则传参数“T, T&, T*”，这种情况下与上面只能实现iterator的代码相同。

使用const_iterator则传参“T, const T&, const T*”，使得解引用操作和成员访问操作被const限制从而不能被修改。

template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;

3.list容器剖析

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;

	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);
	}

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

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}
	void clear(){
		auto it = begin();
		while (it != end())
		{
			it = erase(it);
		}
	}

	iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

	void push_front(const T& x){
		insert(begin(), x);
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}

	iterator erase(iterator pos)
	{
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}

private:
	Node* _head;
};

3.1 迭代器首尾的实现

typedef list_node<T> Node;
public:
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_iterator;

	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);
	}

在构造实例时，会将_head初始化，当执行插入删除操作时，_head类似于一个哨兵头节点。end（）在链表最后一个元素后面一个位置，也就是_head，_head的下一个节点是第一个元素。 

iterator begin()调用可修改迭代器，list_iterator的构造函数将_head->next初始化为一个指针节点。

const_iterator begin()调用const迭代器， list_iterator的构造函数将_head->next初始化为一个指针节点。同时该指针节点的解引用和成员访问受const保护。

3.2 构造和析构

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

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}

（1）默认构造调用空初始化，动态分配一个节点空间 ，前后指针都指向自己。例如：

henu::list<int> lt1;

 （2）拷贝构造，先空初始化申请空间，再将要拷贝的内容一个一个的push_back到申请的空间中

list(const list<T>& lt){
	empty_init();
    for (auto& e : lt){
		push_back(e);
	}
}
list(size_t n, const T& val = T()){
	empty_init();
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

（3）这是一种构造的特殊实现方式，将要拷贝的内容直接与目标变量交换，而由于没有传地址也没有引用传参，所以在此函数作用域中所进行的修改不会对原变量产生任何影响。

list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

（4） 析构，使用clear删除每一个节点，最后删除头结点，将其置为空

~list(){
	clear();

	delete _head;
	_head = nullptr;
}
void clear(){
	auto it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

3.3  插入删除

（1）插入操作首先定义一个临时节点cur指向要插入的位置pos，再定义一个节点指向cur的前一个位置，随后给新节点申请空间并初始化，然后就是新插入节点与两边节点 前后指针的重新指向。

iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
        Node* prev = cur->_prev;
		Node* newnode = new Node(val);


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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

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

（2）删除节点首先定义一个临时指针将要删除的节点保存下来，然后修改前后节点的指针指向，最后删除节点，返回删除节点的下一个节点。

	iterator erase(iterator pos){
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}	
    void pop_front(){
		erase(begin());
	}
	void pop_back(){
		erase(--end());
	}

 3.4 结合实例深入剖析

我们使用下面这段代码结合调试来深入剖析list容器

int main()
{
	henu::list<int> lt1;
	lt1.push_back(1);
	lt1.push_front(2);
	lt1.pop_back();
	lt1.pop_front();
	
	for (auto e : lt1)
	{
		cout << e << " ";
	}
	return 0;
}

3.4.1构造 lt1

当程序运行到henu::list<int> lt1;时，程序会跳转到henu::list中的list构造函数来构造lt1

_head申请一个新的节点空间，这里会调用list_node的构造函数将_head初始化

最后完成节点指针的指向，这样lt1节构造完成了，此时lt1中只有一个_head哨兵节点

3.4.2 尾插头插

将1尾插到lt1中，调用push_back

调用Insert，因为是传递end()作为位置参数来插入元素，因此end（）会在每次调用push_back时先被构造，然后再调用insert

调用iterator end（），返回指向链表尾部哨兵节点的 迭代器

调用insert（）

调用list_node，申请一个新的节点

将该节点初始化

完善指针指向，最后返回一个指向新插入节点的迭代器，因此调用iterator将新节点构造为一个迭代器。list迭代器的*、->、++、--等操作是在list_iterator中特殊实现的，因此需要用iterator构造新节点，该节点才能使用迭代器的*、->、++、--等操作。

生成一个指向一个新节点的迭代器。

最后返回，尾插完成

头插与尾插过程相似

3.4.3 头删尾删

调用pop_front方法头删

因为参数是一个迭代器，所以先构造begin（），再调用erase

调用list_iterator将要返回的节点构造为一个迭代器，指向链表的第一个节点

调用erase方法，在assert中，先构造end（），再判断!=

构造end（），返回一个指向end（）的迭代器，确保传入的pos不等于end（）

判断pos和end（）是否相等

完成指针指向，返回删除节点的下一个节点的迭代器

尾删和头删类似

5.完整代码

#include "list.h"

int main()
{
	henu::list<int> lt1;
	lt1.push_back(1);
	lt1.push_front(2);
	lt1.pop_front();
	lt1.pop_back();

	return 0;
}
#pragma once
#include<iostream>
#include<algorithm>
#include "list.h"
using namespace std;
#include <assert.h>

namespace henu
{
	template <class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		list_node(const T& x = T())
			:_data(x)
			,_next(nullptr)
			,_prev(nullptr)
		{}
	};
	template <class T, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> iterator;
		Node* _node;

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

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

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

		//后置
		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}

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

		//前置
		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		bool operator!=(const iterator& s)
		{
			return _node != s._node;
		}

		bool operator==(const iterator& s)
		{
			return _node == s._node;
		}

	};

	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;

		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);
		}

		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			empty_init();
		}
		list(const list<T>& lt)
		{
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		void swap(list<T>& tmp)
		{
			std::swap(_head, tmp._head);
			std::swap(_size, tmp._size);
		}
		list(size_t n, const T& val = T())
		{
			empty_init();
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		iterator insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(val);
			Node* prev = cur->_prev;

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

			newnode->_next = cur;
			cur->_prev = newnode;
			++_size;

			return iterator(newnode);
		}
		void push_back(const T& x)
		{
			//Node* newnode = new Node(x);
			//newnode->_next = _head;
			//newnode->_prev = _head->_prev;

			//_head->_prev->_next = newnode;
			//_head->_prev = newnode;
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void pop_front()
		{
			erase(begin());
		}
		void pop_back()
		{
			erase(--end());
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* del = pos._node;
			Node* prev = del->_prev;
			Node* next = del->_next;

			prev->_next = next;
			next->_prev = prev;
			delete del;
			--_size;
			return iterator(next);
		}

	private:
		Node* _head;
		size_t _size;
	};
	template <class T>
	void swap(T& a, T& b)
	{
		T c(a); a = b; b = c;
	}

	template <class T>
	void swap(list<T>& a, list<T>& b)
	{
		a.swap(b);
	}
}

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

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

相关文章

在Spring Boot中使用SeeEmitter类实现EventStream流式编程将实时事件推送至客户端

在Spring Boot中使用SeeEmitter类实现EventStream流式编程将实时事件推送至客户端

&#x1f604; 19年之后由于某些原因断更了三年&#xff0c;23年重新扬帆起航&#xff0c;推出更多优质博文&#xff0c;希望大家多多支持&#xff5e; &#x1f337; 古之立大事者&#xff0c;不惟有超世之才&#xff0c;亦必有坚忍不拔之志 &#x1f390; 个人CSND主页——Mi…
阅读更多...
Maven下载配置

Maven下载配置

目录 Win下载配置maven的环境变量 Mac下载安装配置环境变量 MavenSetting.xml文件配置 Win 下载 https://maven.apache.org/ 在主页面点击Download 点击archives 最好不要下载使用新版本&#xff0c;我使用的是maven-3.6.3&#xff0c;我们点击页面下方的archives&#xff0…
阅读更多...
小程序获取微信运动步数

小程序获取微信运动步数

1、用户点击按钮&#xff0c;在小程序中触发getuserinfo方法&#xff0c;获取用户信息 <scroll-view class"scrollarea" scroll-y type"list"><view class"container"><button bind:tap"getLogin">获取</button&…
阅读更多...
OSCP - Proving Grounds - BullyBox

OSCP - Proving Grounds - BullyBox

主要知识点 如果发现有域名&#xff0c;则可以加入/etc/hosts后重新执行nmap,nikto等扫描dirsearch的时候可以使用完整一些的字典文件&#xff0c;避免漏掉信息.git dump 具体步骤 执行nmap 扫描&#xff0c;发现 80和22端口开放,访问后发现被重定向到 bullybox.local Star…
阅读更多...
MIAOYUN信创云原生项目亮相西部“中试”生态对接活动

MIAOYUN信创云原生项目亮相西部“中试”生态对接活动

近日&#xff0c;以“构建‘中试’生态&#xff0c;赋能科技成果转化”为主题的“科创天府智汇蓉城”西部“中试”生态对接活动在成都高新区菁蓉汇隆重开幕。活动分为成果展览、“中试”生态主场以及成果路演洽谈对接三大板块。在成果展览环节&#xff0c;成都元来云志科技有限…
阅读更多...
计算机网络 （47）应用进程跨越网络的通信

计算机网络 （47）应用进程跨越网络的通信

前言 计算机网络应用进程跨越网络的通信是一个复杂而关键的过程&#xff0c;它涉及多个层面和组件的协同工作。 一、通信概述 计算机网络中的通信&#xff0c;本质上是不同主机中的应用进程之间的数据交换。为了实现这种通信&#xff0c;需要借助网络协议栈中的各层协议&#x…
阅读更多...
封装svg图片展示及操作组件——svgComponent——js技能提升

封装svg图片展示及操作组件——svgComponent——js技能提升

template部分 <template><div class"canvas-wrapper" ref"canvasWrapper"><svg:viewBox"computedViewBox"ref"svgCanvas"xmlns"http://www.w3.org/2000/svg"xmlns:xlink"http://www.w3.org/1999/xlink…
阅读更多...
大数据,Hadoop,HDFS的简单介绍

大数据,Hadoop,HDFS的简单介绍

大数据 海量数据&#xff0c;具有高增长率、数据类型多样化、一定时间内无法使用常规软件工具进行捕捉、管理和处理的数据集 合 大数据的特征: 4V Volume : 巨大的数据量 Variety : 数据类型多样化 结构化的数据 : 即具有固定格式和有限长度的数据 半结构化的数据 : 是…
阅读更多...
EAMM: 通过基于音频的情感感知运动模型实现的一次性情感对话人脸合成

EAMM: 通过基于音频的情感感知运动模型实现的一次性情感对话人脸合成

EAMM: 通过基于音频的情感感知运动模型实现的一次性情感对话人脸合成 1所有的材料都可以在EAMM: One-Shot Emotional Talking Face via Audio-Based Emotion-Aware Motion Model网站上找到。 摘要 尽管音频驱动的对话人脸生成技术已取得显著进展&#xff0c;但现有方法要么忽…
阅读更多...
基于STM32的智能门锁安防系统（开源）

基于STM32的智能门锁安防系统（开源）

目录 项目演示 项目概述 硬件组成&#xff1a; 功能实现 1. 开锁模式 1.1 按键密码开锁 1.2 门禁卡开锁 1.3 指纹开锁 2. 功能备注 3. 硬件模块工作流程 3.1 步进电机控制 3.2 蜂鸣器提示 3.3 OLED显示 3.4 指纹与卡片管理 项目源代码分析 1. 主程序流程 (main…
阅读更多...
2024年度总结：从后端Java到全栈成长的蜕变

2024年度总结：从后端Java到全栈成长的蜕变

目录 前言1. 用数据与实践书写成长篇章2. 技术与生活的双重蜕变3. 技术的进阶与生活的绽放 前言 今年是我入行的第十年&#xff0c;也是记录在CSDN平台上的第五年。这五年来&#xff0c;我始终坚持记录成长的点滴&#xff0c;将个人事业与博客创作紧密相连。一路走来&#xff0…
阅读更多...
行人识别检测数据集，yolo格式，PASICAL VOC XML，COCO JSON,darknet等格式的标注都支持，准确识别率可达99.5%

行人识别检测数据集，yolo格式，PASICAL VOC XML，COCO JSON,darknet等格式的标注都支持，准确识别率可达99.5%

作者简介&#xff1a; 高科&#xff0c;先后在 IBM PlatformComputing从事网格计算&#xff0c;淘米网&#xff0c;网易从事游戏服务器开发&#xff0c;拥有丰富的C&#xff0c;go等语言开发经验&#xff0c;mysql&#xff0c;mongo&#xff0c;redis等数据库&#xff0c;设计模…
阅读更多...
Web3 游戏周报（1.13 - 1.19）

Web3 游戏周报（1.13 - 1.19）

回顾上周的区块链游戏概况&#xff0c;查看 Footprint Analytics 与 ABGA 最新发布的数据报告。 【1.13–1.19】Web3 游戏行业动态 索尼区块解决方案实验室 (Sony BSL) 宣布其以太坊 L2 区块链 Soneium 主网上线。Hyve Labs 融资 275 万美元&#xff0c;推动 Web3 游戏基础设…
阅读更多...
Java RSA加密工具类（含密钥对生成和根据私钥计算公钥）

Java RSA加密工具类（含密钥对生成和根据私钥计算公钥）

RSA算法是一种常用的非对称加密算法&#xff0c;它具有以下主要特点&#xff1a; 1.非对称性&#xff1a;RSA 使用一对密钥——公钥和私钥。公钥用于加密&#xff0c;私钥用于解密&#xff0c;也可以反过来使用私钥签名、公钥验证。相对于对称加密的单一密钥&#xff0c;非对称…
阅读更多...
无数据库开源Wiki引擎WikiDocs

无数据库开源Wiki引擎WikiDocs

简介 什么是 WikiDocs &#xff1f; WikiDocs 是一个无数据库的开源 Markdown 文件平面 Wiki 引擎。它旨在提供一个简单、灵活且易于使用的 Wiki 解决方案&#xff0c;允许用户创建和管理文档而无需依赖传统数据库。 主要特点 无数据库&#xff1a;使用纯文本文件存储数据&am…
阅读更多...
Spring Boot 配置（官网文档解读）

Spring Boot 配置（官网文档解读）

目录 摘要 Spring Boot 配置加载顺序 配置文件加载顺序 Spring Boot 配置加载方式 Value Value 注解简单示例 ConfigurationProperties 启动 ConfigurationProperties ConfigurationProperties 验证 ConfigurationProperties 与 Value 对比 Autowired Autowired 自…
阅读更多...
Comment(爆破+git泄漏+二次注入)

Comment(爆破+git泄漏+二次注入)

通过爆破密码的后三位&#xff0c;获得账号为&#xff1a;zhangwei666 F12查看控制台 使用bugscanteam的githack工具&#xff0c;下载泄漏的源码&#xff0c;根据控制台的提示&#xff0c;完整源码还在历史的commit中 git log –reflog 查看历史记录 查看最新的提交记录&#…
阅读更多...
C++otlv4连接sql serveer使用记录（注意点）

C++otlv4连接sql serveer使用记录（注意点）

C使用otlv4在做插入时&#xff0c;有一些设计的坑需要注意 插入数据&#xff1a; 当要给表中插入单个字符时&#xff0c;数据库表设计使用varchar(1)是合理的&#xff0c;但是otlv4一直报错char。 后续查很久才知道&#xff0c;otlv4所写的绑定的字符数组的长度应该实际数组…
阅读更多...
2024又是一年的CSDN之旅-总结过去展望未来

2024又是一年的CSDN之旅-总结过去展望未来

一、前言 一年就这样在忙忙碌碌的工作和生活中一晃而过&#xff0c;总结今年在CSDN上发表的博客&#xff0c;也有上百篇之多&#xff0c;首先感谢CSDN这个平台&#xff0c;能让我有一个地方记录工作中的点点滴滴&#xff0c;也在上面学到了不少知识&#xff0c;解决了工作中遇到…
阅读更多...
JDK长期支持版本（LTS）

JDK长期支持版本（LTS）

https://blogs.oracle.com/java/post/the-arrival-of-java-23 jdk长期支持版本&#xff08;LTS&#xff09;&#xff1a;JDK 8、11、17、21&#xff1a;
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023