C++《list的模拟实现》

news2024/11/6 3:27:52

在上一篇C++《list》专题当中我们了解了STL当中list类当中的各个成员函数该如何使用，接下来在本篇当中我们将试着模拟实现list，在本篇当中我们将通过模拟实现list过程中深入理解list迭代器和之前学习的vector和string迭代器的不同，接下来就开始本篇的学习吧！！！

1.实现各个函数之前的工作 

在list模拟实现中由于是使用类模板来模拟实现list，因此在此list内的函数声明与定义就不分离，这里的原因接下来在模板进阶篇章中会进行讲解。

所以只需要两个文件list.cpp与test.cpp；在list.cpp内实现list类，在test测试实现的list各个成员函数是否满足我们的要求。并且为了避免我们模拟实现的list和std命名空间内的std冲突，在此要将模拟实现的list放在我们新创建的命名空间内

完成了程序文件的实现接下来来实现list类内的成员变量，由于STL内的list其实是一个双链表也就是带头双向循环链表，因此和之前在数据结构内实现链表一样先要实现一个结构体来表示链表的节点

注：链表的节点也是用模板来实现这样就可以使得链表的节点可以存储任意类型的数据。并且由于要实现的是双链表因此链表的节点当中有三个数据分别是存储的数据、指向前一个节点的指针、指向后一个节点的指针

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};


}

由于以上的类在之后创建的list类当中使用到list_node内的成员函数以及成员变量，因此就直接将该类用struct来创建，这样就会使得内部的成员函数以及成员变量默认都是公有的，这是你可能有会有疑惑这样不会使得用户可以修改程序底层的数据破坏原有的封装了吗？

在此其实时不会出现这样的问题，这是因为用户在使用时时无法感受到容器底层的结构的，就比如在学习list底层之前用户是无法感知到list底层是带头的链表，无法感知到底层的节点存储着什么数据，其实在此就是一种隐形的封装。所以就算程序底层的一些是公有的，但是对应用户来说也是属于封闭的，就像是“黑箱”一样

在以上链表节点的结构体当中我们还实现了默认构造函数，这样就可以让之后每创建一个节点都能在定义之后自动初始化

实现了表示链表节点的结构体之后接下来就可以实现list类内的成员变量了

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};


	template<class T>
	class list
	{
		typedef list_node<T> Node;
    public:
        //成员函数……

	private:
		Node* head;
		size_t _size;

	};


}

在此list类的成员变量为两个；一个是list对象内的头节点head，另一个list对象内的有效节点数size 

2. list模拟实现

在以上我们实现了程序文件的创建、list类内成员变量的实现，接下来就可以一一模拟实现list内的成员函数了

2.1 无参构造函数

在list的构造函数中我们先实现无参的构造函数其他的构造函数在实现了插入函数insert之后再实现，这样的原因是使用insert来插入就不需要我我们显示的开空间而是将这些工作交给inert函数来实现，这样其他的构造函数写起来就较为简洁

在list内无参的构造函数中由于list底层要实现的是带头双向循环链表，因此在无参构造时要创建一个头节点也就是哨兵位节点

在list.cpp内实现无参构造函数，代码如下所示：

template<class T>
class list
{
	typedef list_node<T> Node;

public:
	//成员函数……

	list()
	{
		EmptyInit();
	}


private:
	Node* head;
	size_t _size;

	void EmptyInit()
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}

};

2.2 size与empty

在此size和empty的函数实现较为简单，以下就直接实现代码

代码如下所示：

size_t size()const
{
	return _size;
}

bool empty()
{
	return _size == 0;
}

2.3 ⭐迭代器

在模拟实现list当中我们需要重点学习的就是list内的迭代器该如何实现，前面说过，大家可将迭代器暂时理解成类似于指针，但是在list就不能这样认为了；这是由于list底层节点物理空间不一定是连续的，所以我们就不能简单认为迭代器就是指针，那么接下来就来分析list内的迭代器该如何实现

首先要来分析的是和之前实现string和vector的迭代器不同由于无法使用原生指针来实现迭代器，在之前我们了解了list的迭代器是属于双向迭代器，那么在之后list迭代器要能实现迭代器的++与--，这就使得要实现这两个运算符的重载函数。这时你可能会简单的认为直接在list类内实习运算符重载函数不就可以实现要求的了，但是在此就会存在两个非常严重的问题：
首先是在不同的容器实现迭代器就是为了在用户使用时屏蔽底层的细节，屏蔽不同容器底层结构上的差异，通过封装底层的差异与细节来给用户实现统一的访问方式，因此如果在list内实现迭代器就会使得在之后的list迭代器++或者--时就直接通用对对象++或者--就能实现操作，这种实现不就和我们实现迭代器的初衷违背了吗？

其次就是如果是将迭代器实现在list类内，当我们对一个对象进行++或者--之后，该对象内底层的指向头节点指针不就改变了吗？这就会造成之后无法找到头节点，这就会使得之后进行的操作会出现各种问题，要解决这个问题就需要在list类内再创建多个指向头节点的指针，但是这样的话要创建多少个呢，如果是多个迭代器同时遍历list对象那么存在创建的头节点指针数不够怎么办

通过以上的分析就可以得出在list要实现迭代器就不能将迭代器实现在list类内部，那么正确的解决方式是什么呢？

在此合理的方法是载创建一个类list_iterator去封装节点的指针，将list对象内节点的指针作为该类的成员变量，之后使用这个新的类来作为迭代器。在此封装了节点的指针之后就可以重载我们想要实现的*、++、--等的运算符。并且这种实现迭代器的方式就不会出现以上的问题

那么接下来就来实现实现list_iterator类

由于在list类以及之后用户在实现list的迭代器时都会调用list_iterator的内部成员，因此list_iterator也和list_node一样不做访问限定符的限制，在此也使用struct来定义类

以下就先来实现list_iterator内的构造函数

template<class T>
struct list_iterator
{
    //为了简化之后的代码，将以下的两个类型重命名
	typedef list_node<T> Node;
    typedef list_iterator<T> Self;


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

	}

    //节点指针
	Node* _node;
};

我们知道在链表的节点解引用时想要得到的是对应节点内的数据data，在此接下来就在list_iterator内重载*运算符

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

为了能实现对节点内的数据进行读和写，那么就下需要想以上一样将*运算符重载的函数返回值为该节点内数据的引用

接下来来实现迭代器中的++与--，在此由于list为双向迭代器因此我们要实现前置++与--、后置++与-- 

//前置++
Self& operator++()
{
	_node = _node->next;
	return *this;
}
//后置++
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;
}

注：在此的后置++和后置--=要加一个形参int的原因在之前C++《类和对象》章节就讲解过，这是为了使得前置和后置函数构成函数重载，后置加一个参数便于区分

在迭代器的使用当中通常还会判断两个迭代器是否相等，那么接下来就来实现==与!=的运算符重载函数

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

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

接下来我们还要实现一个之前没有实现过的运算符->，要实现这个运算符是因为list对象的类型可以是自定义类型，那么当类型是自定义类型时以上实现的迭代器使用*得到的是整个自定义类型对象，那么如果我们要得到的是该自定义类型内的数据就需要再通过再一次解引用才能实现。

那么为了能一步实现以上的操作就来实现运算符->

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

注：在使用以上操作符时，当list对象为自定义类型时，要得到自定义类型对象内的数据正常应该是要迭代器->->自定义类型对象内的变量，但在此为了可读性就省略一个->，变成迭代器->自定义类型对象内的变量

以上我们就完成了list的普通迭代器，那么const迭代器该如何实现呢？

在此你会认为再创建一个const_list_iterator就可以实现const迭代器，只需要将该类内的部分函数的返回值修改就可以满足需求了。

以上这种方式也是可以满足要求的，但以上这样实现虽然能满足要求但是两个const_list_iterator和list_iterator高度的相识，这样就会使得代码很冗余，那么该如何实现呢？

其实在原本的list_iterator类的模板参数再加两个就可以解决，这就不需要实现两个类了

实现代码如下所示：

注：在此类模板的第一个参数T表示list对象内存储的数据类型，第二个参数Ref表示的是T类型的引用，第三个参数Pre表示T类型的指针

template<class T, class Ref, class Ptr>
struct list_iterator
{
 //为了简化之后的代码，将以下的两个类型重命名
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> Self;


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

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


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

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

	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& l)
	{
		return _node != l._node;
	}

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


	Node* _node;


};

这时list类实现的begin()和end()函数就如下所示：

template<class T>
class list
{
	typedef list_node<T> Node;
public:
//为了将保证的用户能使用list的迭代器需要将以上我们创建的迭代器类型进行重命名
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_iterator;



public:
	
	list()
	{
		EmptyInit();
	}




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

	}



private:
	Node* head;
	size_t _size;

	void EmptyInit()
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}

};

注：前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

2.4 insert与erase

通过之前的学习我们知道list内实现了insert和erase来分别实现任意位置的插入和删除，并且要删除和插入的位置是通过相应的迭代器位置实现，接下来我们就来试着实现这两个函数的代码

先来实现insert函数的代码
在insert函数当中我们要实现的操作是在pos迭代器之前插入指定的值，要实现这个操作就需要先创建一个新的节点之后将指定的值存储到节点当中，之后改节点插入到pos迭代器指向的节点和pos迭代器指向的节点之前的节点中间。以上要实现操作就和之前我们数据结构中学习的双链表任意位置插入数据实现过程类型

实现代码如下所示：

iterator insert(iterator pos, const T& x)
{
	Node* cur = pos._node;
	Node* newnode = new Node(x);
	Node* Prev = cur->prev;
	//Prev newnode  cur 
	Prev->next = newnode;
	cur->prev = newnode;
	newnode->prev = Prev;
	newnode->next = cur;
	++_size;
	return iterator(newnode);
}

接下来来实现erase函数的代码

在erase函数当中我们要实现的操作是将pos迭代器指向的节点删除，要实现这个操作就需要先将原来pos迭代器指向的节点之前的节点的next指针指向原来pos迭代器指向的节点之后的节点，将原来pos迭代器指向的节点之后的节点的prev指针指向原来pos迭代器指向的节点之前的节点，之后再将原pos迭代器指向的节点释放，最后返回新节点的迭代器。以上要实现操作就和之前我们数据结构中学习的双链表任意位置删除数据类似

实现代码如下所示：

iterator erase(iterator pos)
{
	Node* cur = pos._node;
	Node* Prev = cur->prev;
	Node* Next = cur->next;
	//Prev cur Next
	Prev->next = Next;
	Next->prev = Prev;
	delete cur;
	pos = Next;
	--_size;
	return iterator(pos);
}

2.5 push_back、push_front、pop_back、pop_front

实现了insert和erase之后要实现头尾插入与删除就简单了，在这些函数内部直接通过调用之前实现的insert和erase就能实现要求了

实现代码如下所示：

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


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


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


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

2.6 构造函数（含参）

在一开始我们实现了无参的构造函数，但仅仅这一个函数是无法满足我们的要求的，在此还要实现使用迭代器区间的构造、n个指向值构造、拷贝构造等构造函数。

由于在以上我们实现了插入函数，那么接下来实现构造函数就很简单了，在构造函数当中将数据插入到对象内就直接通过调用实现的插入函数就可以实现了

实现代码如下所示：

//拷贝构造
list(const list<T>& lt)
{
	EmptyInit();
	for (auto& i : lt)
	{
		push_back(i);
	}
}

//n个指定的值x构造
list(int n, const T& x)
{
	EmptyInit();
	for (int i = 0; i < n; i++)
	{
		push_back(x);
	}
}

//迭代器区间构造
template<class InputIterator>
list(InputIterator first, InputIterator fin)
{
	EmptyInit();
	while (first != fin)
	{
		push_back(*first);
		++first;
	}

}

2.7 析构函数

在list内由于成员变量是有资源的申请的，那么编译器自动生成的析构函数就无法满足要求，需要我们显示的写析构函数。在此在析构函数内要实现的是将链表的节点一一 释放（包括头节点）

在list.cpp内实现析构函数，代码如下所示：


		~list()
		{
			clear();
			delete head;
			head = nullptr;
		}


		void clear()
		{
			auto s = begin();
			while (s != end())
			{
				s=erase(s);
			}
		}

2.8 swap

在此在list类当中实现一个函数，在list类外也要实现一个swap函数，这样就会在我们使用参数为两个list对象的swap不会调用到算法库内的swap函数，这和之前在vector章节实现两个swap的原因类型

实现代码如下所示：

//list类内的swap
void swap(list<T>& lt)
{
	std::swap(head, lt.head);
	std::swap(_size, lt._size);
}


//list类外的swap函数
template<class T>
void swap(list<T>& lt1, list<T>& lt2)
{
	lt1.swap(lt2);
}

2.9 赋值运算符重载

在此在模拟实现的list类内赋值运算符的重载函数我们可以直接借助swap来实现

实现代码如下所示：

list<T>& operator=(list<T> tmp)
{
	swap(tmp);
	return *this;
}

2.10 front和back

在list当中front和back函数是用于分别得到list对象当中链表第一个有效节点和尾节点

实现代码如下所示：

T& front()
{
	return head->next->date;
}

const T& front()const
{
	return head->next->date;
}
T& back()
{
	return head->prev->date;
}

const T& back()const
{
	return head->prev->date;
}


 

3.完整代码

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};

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

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

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


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

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

		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& l)
		{
			return _node != l._node;
		}

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


		Node* _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;




	public:
		

		list()
		{
			EmptyInit();
		}


		//拷贝构造
		list(const list<T>& lt)
		{
			EmptyInit();
			for (auto& i : lt)
			{
				push_back(i);
			}
		}

		//n个指定的值x构造
		list(int n, const T& x)
		{
			EmptyInit();
			for (int i = 0; i < n; i++)
			{
				push_back(x);
			}
		}

		//迭代器区间构造
		template<class InputIterator>
		list(InputIterator first, InputIterator fin)
		{
			EmptyInit();
			while (first != fin)
			{
				push_back(*first);
				++first;
			}

		}



		list<T>& operator=(list<T> tmp)
		{
			swap(tmp);
			return *this;
		}


		~list()
		{
			clear();
			delete head;
			head = nullptr;
		}



		size_t size()const
		{
			return _size;
		}

		bool empty()
		{
			return _size == 0;
		}

		void clear()
		{
			auto s = begin();
			while (s != end())
			{
				s=erase(s);
			}
		}


		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 push_back(const T& x)
		{
			insert(end(), x);
		}


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


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


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

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* Prev = cur->prev;
			//Prev newnode  cur 
			Prev->next = newnode;
			cur->prev = newnode;
			newnode->prev = Prev;
			newnode->next = cur;
			++_size;
			return iterator(newnode);
		}


		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* Prev = cur->prev;
			Node* Next = cur->next;
			//Prev cur Next
			Prev->next = Next;
			Next->prev = Prev;
			delete cur;
			pos = Next;
			--_size;
			return iterator(pos);
		}

		void swap(list<T>& lt)
		{
			std::swap(head, lt.head);
			std::swap(_size, lt._size);
		}
	

		T& front()
		{
			return head->next->date;
		}

		const T& front()const
		{
			return head->next->date;
		}
		T& back()
		{
			return head->prev->date;
		}

		const T& back()const
		{
			return head->prev->date;
		}



	private:
		Node* head;
		size_t _size;

		void EmptyInit()
		{
			head = new Node();
			head->next = head;
			head->prev = head;
		}

	};


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

}

以上就是《list的模拟实现》章节的全部内容了，希望能得到你的点赞和收藏

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

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

相关文章

讲讲⾼可用的原则？

讲讲⾼可用的原则？

大家好&#xff0c;我是锋哥。今天分享关于【讲讲⾼可用的原则&#xff1f;】面试题。希望对大家有帮助&#xff1b; 讲讲⾼可用的原则&#xff1f; 1000道 互联网大厂Java工程师 精选面试题-Java资源分享网 在当今信息化时代&#xff0c;随着互联网技术的快速发展&#xff0…
阅读更多...
003-Kotlin界面开发之声明式编程范式

003-Kotlin界面开发之声明式编程范式

概念本源 在界面程序开发中&#xff0c;有两个非常典型的编程范式&#xff1a;命令式编程和声明式编程。命令式编程是指通过编写一系列命令来描述程序的运行逻辑&#xff0c;而声明式编程则是通过编写一系列声明来描述程序的状态。在命令式编程中&#xff0c;程序员需要关心程…
阅读更多...
Ubuntu 20.04 部署向量数据库 Milvus + Attu

Ubuntu 20.04 部署向量数据库 Milvus + Attu

前言 最开始在自己的办公电脑&#xff08;无显卡的 windows 10 系统&#xff09; 上使用 Docker Desktop 部署了 Milvus 容器&#xff0c;方便的很&#xff0c; 下载 Attu 也很方便&#xff0c;直接就把这个向量数据库通过 Attu 这个图形化界面跑了起来&#xff0c;使用起来感…
阅读更多...
Linux（inode + 软硬链接 图片+大白话）

Linux（inode + 软硬链接 图片+大白话）

后面也会持续更新&#xff0c;学到新东西会在其中补充。 建议按顺序食用&#xff0c;欢迎批评或者交流&#xff01; 缺什么东西欢迎评论&#xff01;我都会及时修改的&#xff01; 在这里真的很感谢这位老师的教学视频让迷茫的我找到了很好的学习视频 王晓春老师的个人空间…
阅读更多...
CM API方式设置YARN队列资源

CM API方式设置YARN队列资源

简述 对于CDH版本我们可以参考Fayson的文章,本次是CDP7.1.7 CM7.4.4 ,下面只演示一个设置队列容量百分比的示例,其他请参考cloudera官网。 获取cookies文件 生成cookies.txt文件 curl -i -k -v -c cookies.txt -u admin:admin http://192.168.242.100:7180/api/v44/clusters …
阅读更多...
【Linux】简易版shell

【Linux】简易版shell

文章目录 shell的基本框架PrintCommandLineGetCommandLineParseCommandLineExecuteCommandInitEnvCheckAndExecBuildCommand代码总览运行效果总结 shell的基本框架 要写一个命令行我们首先要写出基本框架。 打印命令行获取用户输入的命令分析命令执行命令 基本框架的代码&am…
阅读更多...
基于MySQL的企业专利数据高效查询与统计实现

基于MySQL的企业专利数据高效查询与统计实现

背景 在进行产业链/产业评估工作时&#xff0c;我们需要对企业的专利进行评估&#xff0c;其中一个重要指标是统计企业每一年的专利数量。本文基于MySQL数据库&#xff0c;通过公司名称查询该公司每年的专利数&#xff0c;实现了高效的专利数据统计。 流程 项目流程概述如下&…
阅读更多...
盘点 2024 十大免费/开源 WAF

盘点 2024 十大免费/开源 WAF

WAF 是 Web Application Firewall 的缩写&#xff0c;也被称为 Web 应用防火墙。区别于传统防火墙&#xff0c;WAF 工作在应用层&#xff0c;对基于 HTTP/HTTPS 协议的 Web 系统有着更好的防护效果&#xff0c;使其免于受到黑客的攻击。 近几年经济增速开始放缓&#xff0c;科…
阅读更多...
鸿蒙进阶-AlphabetIndexer组件

鸿蒙进阶-AlphabetIndexer组件

大家好&#xff0c;这里是鸿蒙开天组&#xff0c;今天我们来学习AlphabetIndexer组件&#xff0c;喜欢就点点关注吧&#xff01; 通过 AlphabetIndexer 组件可以与容器组件结合&#xff0c;实现导航联动&#xff0c;以及快速定位的效果 核心用法 AlphabetIndexer不是容器组件…
阅读更多...
【Unity】【游戏开发】Sprite背景闪烁怎么解决

【Unity】【游戏开发】Sprite背景闪烁怎么解决

【现象】 VR游戏中&#xff0c;给作为屏幕的3D板子加上Canvas后再加背景image&#xff0c;运行时总是发现image闪烁不定。 【分析】 两个带颜色的object在空间上完全重合时也遇到过这样的问题&#xff0c;所以推测是Canvas的image背景图与木板的面重合导致。 【解决方法】 …
阅读更多...
sublime Text中设置编码为GBK

sublime Text中设置编码为GBK

要在sublime Text中设置编码为GBK&#xff0c;请按照以下步骤操作 1.打开Sublime Text编辑器, 2.点击菜单栏中的“Preferences”(首选项)选项&#xff0c;找打Package Control选项。 3.点击Package Control&#xff0c;随后搜索Install Package并点击&#xff0c;如下图 4.再…
阅读更多...
队列与栈的代码对比(Java)

队列与栈的代码对比(Java)

目录 链表实现队列 数组实现队列 链表实现栈 数组实现栈 图片: 链表实现队列 package Queue;import java.util.Iterator;public class LinkedListQueue <E> implements Queue<E>, Iterable<E>{//单向环形哨兵链表//节点类private static class Node<…
阅读更多...
一些常规IP核功能

一些常规IP核功能

一，util_vector_logic util_vector_logic 主要支持以下类型的逻辑操作： 逻辑与（AND）： 当所有输入都为1时，输出为1，否则为0。逻辑或（OR）： 当任意输入为1时，输出为1，否则为0。逻辑非（NOT）： 当输入为1时，输出为0；输入为0时，输出为1。异或（XOR）： 当输入中有奇…
阅读更多...
Docker篇（Docker安装）

Docker篇（Docker安装）

目录 一、Centos7.x 1. yum 包更新到最新 2. 安装需要的软件包 3. 设置 yum 源为阿里云 4. 安装docker 5. 安装后查看docker版本 6. 设置ustc镜像源 二、CentOS安装Docker 前言 1. 卸载&#xff08;可选&#xff09; 2. 安装docker 3. 启动docker 4. 配置镜像加速 …
阅读更多...
【c++ gtest】使用谷歌提供的gtest和抖音豆包提供的AI大模型来对代码中的函数进行测试

【c++ gtest】使用谷歌提供的gtest和抖音豆包提供的AI大模型来对代码中的函数进行测试

【c gtest】使用谷歌提供的gtest和抖音豆包提供的AI大模型来对代码中的函数进行测试 下载谷歌提供的c测试库在VsCode中安装抖音AI大模型找到c项目文件夹&#xff0c;使用VsCode和VS进行双开生成gtest代码进行c单例测试 下载谷歌提供的c测试库 在谷歌浏览器搜索github gtest, 第…
阅读更多...
google adsense广告费中国收款结算被银行拒解决办法

google adsense广告费中国收款结算被银行拒解决办法

多年前搞了几个网站&#xff0c;挂了谷歌google adsense广告&#xff0c;不知道不觉到了100美金最低结算&#xff0c;谷歌给我打款&#xff0c;之前是绑定交银银行的。被银行镜内登陆谷歌不合法不合规给拒绝入账&#xff0c;把美金退回了&#xff0c;怎么办&#xff1f; googl…
阅读更多...
蓝桥杯 区间移位--二分、枚举

蓝桥杯 区间移位--二分、枚举

题目 代码 #include <stdio.h> #include <string.h> #include <vector> #include <algorithm> #include <iostream> using namespace std; struct node{ int a,b; }; vector<node> q; bool cmp(node x,node y){ return x.b <…
阅读更多...
书生第四期实训营基础岛——L1G1000书生大模型全链路开源体系

书生第四期实训营基础岛——L1G1000书生大模型全链路开源体系

书生浦语大模型开源开放体系 书生浦语开源一周年历史 2023.7.6&#xff1a;InternLM-7B开源率先免费商用发布全链条开源工具体系2023.9.20&#xff1a;InternLM-20B开源&#xff0c;开源工具链全线升级2024.1.17&#xff1a;InternLM2开源&#xff0c;性能超最新同量级开源模…
阅读更多...
单元测试(Junit)

单元测试(Junit)

系统—模块—子模块&#xff0c;子模块中不可分割的程序单元的测试&#xff0c;单元的粒度根据实际情况可能是 类或方法等。 面向对象编程中&#xff0c;最小单元就是方法。 单元测试目的是在集成测试和功能测试之前对系统可测试单元进行逐一检查和验证。 单元测试基本原则 …
阅读更多...
MySQL表的增删改查(CRUD3约束)

MySQL表的增删改查(CRUD3约束)

这次我们开始先不复习嗷&#xff0c;等到把数据表的删除说完咱们统一&#xff0c;总结书写 1.数据表的删除&#xff1a; 语法&#xff1a; 1. 使用 DROP TABLE 语句删除单个表 基本语法&#xff1a;DROP TABLE [IF EXISTS] table_name; table_name是要删除的表的名称。IF EXIS…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023