STL----vector的模拟实现

news2024/11/16 4:44:11

1. vector的介绍与使用

1.1 vector的介绍

1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。

1.2 vector的使用

我们在学习中，一定要学会查看文档

vector - C++ Reference

这里就是vector的文档，大家可以看一看 

1.2.1 vector的定义与使用 

(constructor)构造函数声明接口说明
vector()（重点）无参构造
vector（size_type n, const value_type& val = value_type()）构造并初始化n个val
vector (const vector& x); （重点）拷贝构造
vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造

vector的类模板可以实例化各种类型，无论是内置类型int，char或是自定义类型string，vector都可以。 

void vector_test1()
{
	vector<int> v();//无参
	vector<char> vv(10, 'x');//构造并初始化
	vector<string> vvv(5, "haha");

	vector<char> vs(vv);//拷贝构造
	vector<string> vvs(vvv.begin()+2, vvv.end());//使用迭代器区间进行初始化定义

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

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

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

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

}

 

1.2.2 iterator的定义与使用

iterator的使用接口说明
begin +
end（重点）		获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置
的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的
reverse_iterator


 

void vector_test2()
{
	vector<char> str;
	str.push_back('a');
	str.push_back('b');
	str.push_back('c');
	str.push_back('d');
	str.push_back('r');
	str.push_back('g');
	str.push_back('y');

	vector<char>::iterator it = str.begin();
	while (it != str.end())
	{
		cout << *it << "  ";
		it++;
	}
	//while (it != str.end())//第二次打印什么都没有，因为迭代器已然失效
	//	                   //it已经指在了str.end()的位置
	//{
	//	cout << *it << "  ";
	//	it++;
	//}
	cout << endl;
	vector<char>::const_reverse_iterator rit = str.rbegin();
	while (rit != str.rend())//逆反打印
	{
		cout << *rit << "  ";
		rit++;
	}
	cout << endl;


	vector<int> arr{ 1,2,3,4,5,6,7, };
	vector<int>::iterator iit = arr.begin();
	while (iit != arr.end())//打印的同时做修改
	{
		(*iit)++;
		cout << *iit << " ";
		iit++;
	}
}

 

1.2.3 vector的空间增长问题 

容量空间接口说明
size获取数据个数
capacity获取容量大小
empty判断是否为空
resize（重点）改变vector的size
reserve （重点）改变vector的capacity

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
resize在开空间的同时还会进行初始化，影响size

void vector_test3()
{
	vector<int> v;//创建一个空的vector数组
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	if (v.empty())
		cout << "该容器为空！" << endl;
	else
		cout<< "该容器bu为空！" << endl;
	cout << endl;

	v.reserve(10);//扩容至10
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	if (v.empty())
		cout << "该容器为空！" << endl;
	else
		cout << "该容器bu为空！" << endl;
	cout << endl;

	v.resize(15,1);//有效字符扩充为15，并填充为1
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	if (v.empty())
		cout << "该容器为空！" << endl;
	else
		cout << "该容器bu为空！" << endl;
	cout << endl;

	v.reserve(5);//容量小于原容量，不做更改
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	if (v.empty())
		cout << "该容器为空！" << endl;
	else
		cout << "该容器bu为空！" << endl;
	cout << endl;

	v.resize(7, 3);//缩小有效字符为7，未被填充的填充为3
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	if (v.empty())
		cout << "该容器为空！" << endl;
	else
		cout << "该容器bu为空！" << endl;
	cout << endl;
}

关于空间增长问题，我们可以看到，当size==capacity时，即vector的_finish==_endOfStorage时，会触发自动扩容机制 。扩容是比较耗费资源的，因此倘若我们直到所需的空间大小，可以提前reserve足够的空间，可以节省扩容消耗。

void vector_test4()
{
	vector<int> v;
	size_t sz = v.capacity();
	for (int i = 0; i < 100; i++)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			cout << "capacity: " << v.capacity() << endl;
			sz = v.capacity();
		}
	}
}

 1.2.4 vector的增删查改

我们发现，vector似乎并不是很支持在其他位置的增删，数组的增删是得不偿失的，往往对一个元素的操作，要挪动一堆元素。

void vector_test5()
{
	vector<int> v;
	v.push_back(1);//尾插
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.pop_back();//尾删
	v.pop_back();
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.push_back(4);
	v.push_back(5);
	vector<int>::iterator pos=find(v.begin(), v.end(), 3);//查找，返回迭代器，需要包含算法头文件，<algorithm>
	cout << *pos << endl;


   
	v.insert(pos, 5);//在pos前插入5
	
	//当插入5时，vector可能会触发扩容机制，扩容后会产生迭代器失效问题，这里的指：
	// 扩容后产生新的空间，原空间释放，而pos指向之前的空间，变成野指针
	vector<int>::iterator poss = find(v.begin(), v.end(), 3);
	poss++;//由于数组的物理地址是连续的，因此可以++，但如list等不连续的空间就不可以
	v.insert(poss, 5, 99);//在poss前插入5个99
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	for (size_t i = 0; i < v.size(); i++)//像数组一样，下标访问
	{
		cout << v[i] << " ";//等同于v.operator[i]
	}
	cout << endl;

	vector<int>::iterator it = v.begin()+3;//it指向第4个位置
	cout << *it << endl;
	it=v.erase(it, it + 3);//从第四个位置开始，删除三个元素，更新it的值
	cout << *it << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> vv{ 3,3,3,3,3 };
	cout << "交换前：" << endl;
	cout << "v: " << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << "vv: " << endl;
	for (auto e : vv)
	{
		cout << e << " ";
	}
	cout << endl;

	v.swap(vv);//交换vector空间
	cout << "交换后：" << endl;
	cout << "v: " << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << "vv: " << endl;
	for (auto e : vv)
	{
		cout << e << " ";
	}
	cout << endl;
}

1.2.5 迭代器失效问题

在前面的代码注释中，我们提到了迭代器失效的问题，那么到底什么是迭代器失效呢？ 

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

迭代器失效分为两种情况：

1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。

以下面的代码为例，倘若插入会触发扩容，那么扩容之后会产生新的vector空间，释放原先的空间，而此时pos仍然指向原来的空间，访问一块已经被释放的空间，会导致崩溃。

那么有人说，如果没有触发扩容，是不是就不会崩溃了？

这个要看编译器，vs下比较严格，即便没有触发扩容，也会崩溃；Linux的g++下可能不会崩溃。 

2. 指定位置元素的删除操作--erase

下面这段代码，我们删除之后更新了it，如果不更新，就会崩溃，这又是为什么呢？

按理说，我们删除当前位置的元素，也就是后面的元素逐个向前挪动覆盖，我的迭代器it不应该有变化才是。但如果我们删除的是最后一个元素呢？it指向v.end()，还能对他解引用吗？

同样这种代码在不同编译器结果不同，如果删除的是其他位置并且没有更新迭代器位置的话，在vs下会崩溃 ，g++下就不会崩溃。

那么如何解决这个问题呢？

其实上面的代码已经告诉我们了，只需要更新迭代器的位置就ok了。 

 2. vector的深度剖析及模拟实现

2.1 深度剖析

下图是根据vector底层源码逻辑构画出的图，vector的三个成员变量都是由迭代器构建的。

迭代器的底层是T*

 begin()指向vector第一个元素的位置，end()指向最后一个元素的下一个位置。

 2.2 模拟实现

2.1 成员变量的构建

这里注意，我们的变量后都有缺省参数，后面实现构造函数会方便很多。


	private:

		iterator _start = nullptr; // 指向数据块的开始

		iterator _finish = nullptr; // 指向有效数据的尾

		iterator _endOfStorage = nullptr; // 指向存储容量的尾

2.2迭代器的实现 

这里我们只实现了正向迭代器的普通与静态对象版本。这个比较简单就不做过多赘述了。

		typedef T* iterator;

		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

 在源码处我们可以看到反向迭代器的实现

2.3 容量与有效字符问题

 关于reserve这里我们需要注意迭代器失效的问题，resize由于我们对reserve进行了复用，因此规避了迭代器失效。

		size_t size() const//size()外界不能做修改
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _endOfStorage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())//如果需要的空间大于原空间容量
			{
				size_t old = size();//这里为什么要记录size呢？
				T* tmp = new T[n];//new一个新的n大小的空间tmp
				if (_start)//如果对象原本就存在
				{
					for (size_t i = 0; i < old; i++)//将空间内的数据转移到tmp
					{
						tmp[i] = _start[i];
					}
					delete[] _start;//释放原空间
				}
				_start = tmp;//更新对象的成员变量
				_finish = _start + old;
				_endOfStorage = _start + n;
			}
			//需要的空间小于原空间容量，不做修改
		}

		void resize(size_t n, const T& value = T())
		{
			if (n > size())
			{
				reserve(n);//复用reserve
				for (size_t i = size(); i < n; i++)//从size()处开始填充
				{
					_start[i] = value;
				}
			}
			else//n<size()
			{
				_finish = _start + n;//缩小空间的有效字符
			}
		}



		///access///

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

		const T& operator[](size_t pos)const
		{
			assert(pos < size());
			return _start[pos];
		}

2.4 插入与删除

这里的insert与erase是由迭代器失效的隐患的，因此需要多加注意。

		void push_back(const T& x)//尾插
		{
			if (_finish == _endOfStorage)//如果空间已满，则需要扩容
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finish = x;
			_finish++;
		}

		void pop_back()//尾删
		{
			assert(size() > 0);
			_finish--;
		}

		void swap(vector<T>& v)//交换，复用std下的swap，实现深拷贝
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endOfStorage, v._endOfStorage);
		}

		iterator insert(iterator pos, const T& x)//插入
		{
			assert(pos >= _start && pos <= _finish);//pos需要在vector对象的迭代器区间内

			if (_finish == _endOfStorage)//容量已满
			{
				size_t len = pos - _start;//这里同样需要记录，因为pos指向旧空间，一旦扩容就会产生新空间
				                         //此时pos失效，
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + len;//在这里更新pos
			}
			iterator end = _finish - 1;
			while (end >= pos)//不能使用memcpy，memcpy本质是浅拷贝
			{
				*(end + 1) = *(end);
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			iterator tmp = pos + 1;
			while (tmp < _finish)
			{
				*(tmp - 1) = *tmp;
				tmp++;
			}
			_finish--;
			return pos;//需要返回pos值，更新外界的pos
		}

2.5 构造，赋值重载与析构

这里复用其他函数会很方便。 

		vector()//由于成员变量的声明处给了缺省值，这里可以不做处理
		{}

		vector(int n, const T& value = T())//构建以t填充的n个有效字符的对象
		{
			resize(n, value);//复用resize
		}

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)//构建以迭代器区间为基础的对象
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

		vector(const vector<T>& v)//拷贝构造
		{
			reserve(v.capacity());//提前reserve，减少开辟空间的损耗
			for (const auto& e : v)
			{
				push_back(e);
			}
		}

		vector<T>& operator= (vector<T> v)//赋值重载，传入赋值对象的拷贝v
		{
			swap(v);//交换v与this，此时this指向赋值对象的拷贝，v指向原this空间
			return *this;//函数结束后，原this空间被释放
		}

		~vector()//析构
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endOfStorage = nullptr;
			}
		}

 3. 浅拷贝与深拷贝的问题

有人会说，在insert与erase中都涉及到了数据的移动覆盖，那我们使用memcpy不就好了吗？
事实证明，这样是不行的。

memcpy的拷贝是浅拷贝，如果vector内嵌的是自定义类型，此时tmp内的string与vstr中的string都指向同一空间。那么后面释放原空间，会调用原空间内string的析构函数，此时tmp对象内的string就会指向已经被释放的空间。因此这里我们使用了最原始的方法。

4. 完整代码 

class vector

{

public:

	// Vector的迭代器是一个原生指针

	typedef T* iterator;

	typedef const T* const_iterator;

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}



	// construct and destroy

	vector()//由于成员变量的声明处给了缺省值，这里可以不做处理
	{}

	vector(int n, const T& value = T())//构建以t填充的n个有效字符的对象
	{
		resize(n, value);//复用resize
	}

	template<class InputIterator>
	vector(InputIterator first, InputIterator last)//构建以迭代器区间为基础的对象
	{
		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}

	vector(const vector<T>& v)//拷贝构造
	{
		reserve(v.capacity());//提前reserve，减少开辟空间的损耗
		for (const auto& e : v)
		{
			push_back(e);
		}
	}

	vector<T>& operator= (vector<T> v)//赋值重载，传入赋值对象的拷贝v
	{
		swap(v);//交换v与this，此时this指向赋值对象的拷贝，v指向原this空间
		return *this;//函数结束后，原this空间被释放
	}

	~vector()//析构
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}

	// capacity

	size_t size() const//size()外界不能做修改
	{
		return _finish - _start;
	}

	size_t capacity() const
	{
		return _endOfStorage - _start;
	}

	void reserve(size_t n)//扩容函数
	{
		if (n > capacity())//如果需要的空间大于原空间容量
		{
			size_t old = size();//这里为什么要记录size呢？
			T* tmp = new T[n];//new一个新的n大小的空间tmp
			if (_start)//如果对象原本就存在
			{
				for (size_t i = 0; i < old; i++)//将空间内的数据转移到tmp
				{
					tmp[i] = _start[i];
				}
				delete[] _start;//释放原空间
			}
			_start = tmp;//更新对象的成员变量
			_finish = _start + old;
			_endOfStorage = _start + n;
		}
		//需要的空间小于原空间容量，不做修改
	}

	void resize(size_t n, const T& value = T())
	{
		if (n > size())
		{
			reserve(n);//复用reserve
			for (size_t i = size(); i < n; i++)//从size()处开始填充
			{
				_start[i] = value;
			}
		}
		else//n<size()
		{
			_finish = _start + n;//缩小空间的有效字符
		}
	}



	///access///

	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos)const
	{
		assert(pos < size());
		return _start[pos];
	}



	///modify/

	void push_back(const T& x)//尾插
	{
		if (_finish == _endOfStorage)//如果空间已满，则需要扩容
		{
			reserve(capacity() == 0 ? 4 : 2 * capacity());
		}
		*_finish = x;
		_finish++;
	}

	void pop_back()//尾删
	{
		assert(size() > 0);
		_finish--;
	}

	void swap(vector<T>& v)//交换，复用std下的swap，实现深拷贝
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_endOfStorage, v._endOfStorage);
	}

	iterator insert(iterator pos, const T& x)//插入
	{
		assert(pos >= _start && pos <= _finish);//pos需要在vector对象的迭代器区间内

		if (_finish == _endOfStorage)//容量已满
		{
			size_t len = pos - _start;//这里同样需要记录，因为pos指向旧空间，一旦扩容就会产生新空间
			                         //此时pos失效，
			reserve(capacity() == 0 ? 4 : 2 * capacity());
			pos = _start + len;//在这里更新pos
		}
		iterator end = _finish - 1;
		while (end >= pos)//不能使用memcpy，memcpy本质是浅拷贝
		{
			*(end + 1) = *(end);
			end--;
		}
		*pos = x;
		_finish++;
		return pos;
	}

	iterator erase(iterator pos)
	{
		assert(pos >= _start && pos < _finish);
		iterator tmp = pos + 1;
		while (tmp < _finish)
		{
			*(tmp - 1) = *tmp;
			tmp++;
		}
		_finish--;
		return pos;//需要返回pos值，更新外界的pos
	}


private:

	iterator _start = nullptr; // 指向数据块的开始

	iterator _finish = nullptr; // 指向有效数据的尾

	iterator _endOfStorage = nullptr; // 指向存储容量的尾

};

 

 

 

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

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

相关文章

西安石油大学数学建模校赛培训（2）matlab的使用

西安石油大学数学建模校赛培训（2）matlab的使用

1.1.MATLAB是什么&#xff1f; MATLAB是MathWorks公司推出的一套高性能数值分析计算软件&#xff0c;其名字来源于"Matrix Laboratory"&#xff08;矩阵实验室&#xff09;的缩写。它将矩阵运算、数值分析、图形处理、编程技术等功能集成在一起&#xff0c;为科学计…
阅读更多...
Linux内核err.h文件分析

Linux内核err.h文件分析

在阅读和编写内核相关的代码时&#xff0c;经常会看到IS_ERR、ERR_PTR等函数。这些函数在内核头文件的err.h中。以我服务器的代码为例&#xff0c;内核版本为5.15。 这个文件的代码如下&#xff1a; /* SPDX-License-Identifier: GPL-2.0 */ #ifndef _LINUX_ERR_H #define _L…
阅读更多...
【漏洞复现】商混ERP系统 DictionaryEdit.aspx接口处存在SQL注入漏洞

【漏洞复现】商混ERP系统 DictionaryEdit.aspx接口处存在SQL注入漏洞

免责声明&#xff1a;文章来源互联网收集整理&#xff0c;请勿利用文章内的相关技术从事非法测试&#xff0c;由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;所产生的一切不良后果与文章作者无关。该…
阅读更多...
SpringBoot学习之ElasticSearch下载安装和启动（Windows版）（三十）

SpringBoot学习之ElasticSearch下载安装和启动（Windows版）（三十）

本文先写windows下的下载安装和启动，后续有时间再补充其他环境下（Mac、Linux、Docker）的，这里我们后续对ElasticSearch简称为ES，读者习惯这一称呼就好。 一，ES下载 可以百度【ElasticSearch官网】或者直接点击这里的ES官网下载地址：​​​​​ Download Elasticsearch…
阅读更多...
Python制作数据可视化大屏

Python制作数据可视化大屏

&#x1f349;CSDN小墨&晓末:https://blog.csdn.net/jd1813346972 个人介绍: 研一&#xff5c;统计学&#xff5c;干货分享          擅长Python、Matlab、R等主流编程软件          累计十余项国家级比赛奖项&#xff0c;参与研究经费10w、40w级横向 文…
阅读更多...
平台介绍-搭建赛事运营平台（2）

平台介绍-搭建赛事运营平台（2）

平台建设的首期就有两个品牌入驻&#xff0c;品牌J和品牌K&#xff0c;第三个品牌正在协商中。 作为一个统一的共享平台&#xff0c;首先要解决的是品牌直接的隔离。 方案一&#xff1a;同服务程序、同库&#xff0c;同表。表中通过字段区分品牌 这是最传统的解决方案。初期开发…
阅读更多...
【STM32嵌入式系统设计与开发】——9Timer(定时器中断实验)

【STM32嵌入式系统设计与开发】——9Timer(定时器中断实验)

这里写目录标题 一、任务描述二、任务实施1、ActiveBeep工程文件夹创建2、函数编辑&#xff08;1&#xff09;主函数编辑&#xff08;2&#xff09;USART1初始化函数(usart1_init())&#xff08;3&#xff09;USART数据发送函数&#xff08; USART1_Send_Data&#xff08;&…
阅读更多...
PTAxt的考研路

PTAxt的考研路

xt是我院19级专业第一&#xff0c;但他认为保研并不能展示他全部的实力&#xff0c;所以他在22年初试一结束就加入了23考研的队伍中&#xff0c;并且他为了填补我院近些年来无北大研究生的空白&#xff0c;毅然决然决定扛起19级的大旗&#xff0c;在学校百年华诞之际献上他最诚…
阅读更多...
elasticsearch 6.8.x 索引别名、动态索引扩展、滚动索引

elasticsearch 6.8.x 索引别名、动态索引扩展、滚动索引

文章目录 引言索引别名&#xff08;alias&#xff09;创建索引别名查询索引别名删除索引别名重命名索引别名 动态索引&#xff08;index template&#xff0c;动态匹配生成索引&#xff09;新建索引模板新建索引并插入数据索引sys-log-202402索引sys-log-202403索引sys-log-202…
阅读更多...
Jakarta项目介绍

Jakarta项目介绍

概述 在升级Spring Boot到3.0版本以后&#xff0c;或升级Spring到6.0版本以上&#xff0c;会发现应用编译失败或启动失败等问题。 经过排查不难得知&#xff0c;Spring 6或Spring Boot 3&#xff08;实际上依赖于Spring 6&#xff09;不再支持javax.开头的一系列依赖包&#…
阅读更多...
【微服务】认识Dubbo+基本环境搭建

【微服务】认识Dubbo+基本环境搭建

认识Dubbo Dubbo是阿里巴巴公司开源的一个高性能、轻量级的WEB和 RPC框架&#xff0c;可以和Spring框架无缝集成。Dubbo为构建企业级微服务提供了三大核心能力&#xff1a; 服务自动注册和发现、面向接口的 远程方法调用&#xff0c; 智能容错和负载均衡官网&#xff1a;https…
阅读更多...
初见 链表

初见 链表

前言 在上篇文章重温数组——顺序表 http://t.csdnimg.cn/9DH9M 后&#xff0c;本篇文章让我们认识一种新的数据结构&#xff1a;链表 认识 概念&#xff1a;链表是⼀种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表 中的指针链接次序实现…
阅读更多...
【JavaEE】进程是什么？

【JavaEE】进程是什么？

文章目录 ✍进程的概念✍进程存在的意义✍进程在计算机中的存在形式✍进程调度 ✍进程的概念 每个应⽤程序运⾏于现代操作系统之上时&#xff0c;操作系统会提供⼀种抽象&#xff0c;好像系统上只有这个程序在运⾏&#xff0c;所有的硬件资源都被这个程序在使⽤。这种假象是通…
阅读更多...
360奇酷刷机 360刷机助手 QGDP360手机QGDP刷机

360奇酷刷机 360刷机助手 QGDP360手机QGDP刷机

360奇酷刷机 360刷机助手 QGDP破解版360手机QGDP刷机 360手机刷机资源下载链接&#xff1a;360rom.github.io 参考&#xff1a;360手机-360刷机360刷机包twrp、root 360奇酷刷机&#xff1a;360高通驱动安装 360手机刷机驱动&#xff1b;手机内置&#xff0c;可通过USB文件传输…
阅读更多...
修改 RabbitMQ 默认超时时间

修改 RabbitMQ 默认超时时间

MQ客户端正常运行&#xff0c;突然就报连接错误&#xff0c; 错误信息写的很明确&#xff0c;是客户端连接超时。 不过很疑虑&#xff0c;为什么会出现连接超时呢&#xff1f;代码没动过&#xff0c;网络也ok&#xff0c;也设置了心跳和重连机制。 最终在官网中找到了答案&am…
阅读更多...
『笔记』可扩展架构设计之消息队列

『笔记』可扩展架构设计之消息队列

前言 众所周知&#xff0c;开发低耦合系统是软件开发的终极目标之一。低耦合的系统更加容易扩展&#xff0c;低耦合的模块更加容易复用&#xff0c;更易于维护和管理。我们知道&#xff0c;消息队列的主要功能就是收发消息&#xff0c;但是它的作用不仅仅只是解决应用之间的通…
阅读更多...
java一和零（力扣Leetcode474）

java一和零（力扣Leetcode474）

一和零 力扣原题 给定一个二进制字符串数组 strs 和两个整数 m 和 n&#xff0c;请你找出并返回 strs 的最大子集的长度&#xff0c;该子集中最多有 m 个 0 和 n 个 1。 示例 1&#xff1a; 输入&#xff1a;strs [“10”, “0001”, “111001”, “1”, “0”], m 5, n …
阅读更多...
基于GA优化的CNN-LSTM-Attention的时间序列回归预测matlab仿真

基于GA优化的CNN-LSTM-Attention的时间序列回归预测matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1卷积神经网络&#xff08;CNN&#xff09;在时间序列中的应用 4.2 长短时记忆网络&#xff08;LSTM&#xff09;处理序列依赖关系 4.3 注意力机制&#xff08;Attention&#xff09; 5…
阅读更多...
基于BP神经网络的城市空气质量数据预测matlab仿真

基于BP神经网络的城市空气质量数据预测matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1 BP神经网络结构 4.2 神经元模型与激活函数 4.3 前向传播过程 4.4反向传播算法及其误差函数 4.5 权重更新规则 4.6 迭代训练 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软…
阅读更多...
Qt_day4:2024/3/25

Qt_day4:2024/3/25

作业1&#xff1a; 完善对话框&#xff0c;点击登录对话框&#xff0c;如果账号和密码匹配&#xff0c;则弹出信息对话框&#xff0c;给出提示”登录成功“&#xff0c;提供一个Ok按钮&#xff0c;用户点击Ok后&#xff0c;关闭登录界面&#xff0c;跳转到其他界面 如果账号和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023