STL----vector的模拟实现

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; // 指向存储容量的尾

};

 

 

 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Vscode + PlatformIO + Arduino 搭建EPS32开发环境

Vscode + PlatformIO + Arduino 搭建EPS32开发环境

Vscode PlatformIO Arduino 搭建EPS32开发环境 文章目录 Vscode PlatformIO Arduino 搭建EPS32开发环境1. Vscode插件安装2. 使用PlatformIO新建工程3.工程文件的基本结构4.一个基本的测试用例Reference 1. Vscode插件安装 如何下载vscode这里不再赘述&#xff0c;完成基本…
阅读更多...
2024-2028年中国丙二醇乙醚（PE）市场行情监测及未来发展前景研究报告

2024-2028年中国丙二醇乙醚（PE）市场行情监测及未来发展前景研究报告

丙二醇乙醚&#xff08;PE&#xff09;又称1-乙氧基-2-丙醇&#xff0c;化学式为C5H12O2&#xff0c;是一种有机化合物。丙二醇乙醚外观呈无色透明液体&#xff0c;微含醚气味&#xff0c;能与水和多数有机溶剂混溶&#xff0c;微溶于乙酸乙酯和氯仿。丙二醇乙醚具有吸湿性、挥…
阅读更多...
ensp中pc机访问不同网络的服务器

ensp中pc机访问不同网络的服务器

拓扑图如下&#xff0c;资源已上传 说明&#xff1a;pc通过2个路由访问server服务器 三条线路分别是192.168.1.0网段&#xff0c;192.168.2.0网段和192.168.3.0网段&#xff0c;在未配置的情况下&#xff0c;pc设备是访问不到server的 具体操作流程 第一&#xff1b;pc设备…
阅读更多...
Redis桌面客户端

Redis桌面客户端

3.4.Redis桌面客户端 安装完成Redis&#xff0c;我们就可以操作Redis&#xff0c;实现数据的CRUD了。这需要用到Redis客户端&#xff0c;包括&#xff1a; 命令行客户端图形化桌面客户端编程客户端 3.4.1.Redis命令行客户端 Redis安装完成后就自带了命令行客户端&#xff1…
阅读更多...
连接数据库（MySQL）的JDBC

连接数据库（MySQL）的JDBC

目录 JDBC简介快速入门API详解DriverManager&#xff08;驱动管理类&#xff09;注册驱动&#xff1a;获取数据库连接(对象)&#xff1a; Connection&#xff08;数据库连接对象&#xff09;获取执行SQL的对象管理事务 Statement(执行SQL语句)执行DML、DDL语句执行DQL语句 Resu…
阅读更多...
ArcGIS矢量裁剪矢量

ArcGIS矢量裁剪矢量

一、利用相交工具 Arctoolbox工具一分析工具一叠加分析一相交
阅读更多...
深度｜庖丁解InnoDB之Buffer Pool

深度｜庖丁解InnoDB之Buffer Pool

以下文章来源于MySQL内核剖析 &#xff0c;作者王康 前言 Buffer Pool是InnoDB中非常重要的组成部分&#xff0c;也是数据库用户最关心的组件之一。Buffer Pool的基本功能并不复杂&#xff0c;设计实现也比较清晰&#xff0c;但作为一个有几十年历史的工业级数据库产品&am…
阅读更多...
那位拿了多个Offer的大佬分享了最新Go面经

那位拿了多个Offer的大佬分享了最新Go面经

和大家分享一下我们 Go就业训练营 和 升职加薪星球 中战友们投稿的真实面经。 这是第一篇&#xff0c;计划还会再更新4篇最新Go面经&#xff0c;都是拿到Offer的那种&#xff01; 欢迎大家关注我的账号&#xff0c;关注之后不迷路。 先秀战绩 虽然不同的公司考察的侧重点不一…
阅读更多...
Linux系统服务

Linux系统服务

文章目录 什么是daemon与服务(service)systemd使用unit分类 通过systemctl管理服务通过systemctl管理单一服务(service unit)通过systemctl查看系统上所有的服务通过systemctl管理不同的操作环境(target unit)通过systemctl分析各服务之间的依赖性与systemd的daemon运行过程相关…
阅读更多...
Codeforces Round 930 (Div. 2) --- D. Pinball --- 题解

Codeforces Round 930 (Div. 2) --- D. Pinball --- 题解

目录 D. Pinball&#xff1a; 题目大意&#xff1a; 思路解析&#xff1a; 代码实现&#xff1a; 代码一&#xff1a; 代码二&#xff1a; D. Pinball&#xff1a; 题目大意&#xff1a; 思路解析&#xff1a; 假设字符串为 >>><<<&#xff0c; 当前位…
阅读更多...
程序员35岁会失业吗？【来自主流AI的回答】

程序员35岁会失业吗？【来自主流AI的回答】

程序员35岁会失业吗&#xff1f; 35岁被认为是程序员职业生涯的分水岭&#xff0c;许多程序员开始担忧自己的职业发展是否会受到年龄的限制。有人担心随着年龄的增长&#xff0c;技术更新换代的速度会使得资深程序员难以跟上&#xff1b;而另一些人则认为&#xff0c;丰富的经…
阅读更多...
STM32CubeIDE基础学习-USART串口通信实验（轮询方式）

STM32CubeIDE基础学习-USART串口通信实验（轮询方式）

STM32CubeIDE基础学习-USART串口通信实验&#xff08;轮询方式&#xff09; 文章目录 STM32CubeIDE基础学习-USART串口通信实验&#xff08;轮询方式&#xff09;前言第1章 硬件介绍第2章 工程配置2.1 工程外设配置部分2.2 生成工程代码部分 第3章 代码编写3.1 串口发送3.1.1 发…
阅读更多...
SqlServer期末复习（数据库原理及应用）持续更新中

SqlServer期末复习（数据库原理及应用）持续更新中

一、SQL语句 1.1 SQL语句知识引入 1.DDL语言(数据定义语言&#xff09;主要是进行定义/改变表的结构、数据类型、表之间的链接等操作&#xff0c;关键字CREATE、DROP、ALTER CREATE TABLE 表面( 列名1 数据类型&#xff0c; 列名2 数据类型&#xff0c; ) ALTER TABLE 表名&a…
阅读更多...
[计算机效率] 文件查重工具：Vistanita Duplicate Finder

[计算机效率] 文件查重工具：Vistanita Duplicate Finder

3.6 文件查重工具&#xff1a;Vistanita Duplicate Finder Vistanita Duplicate Finder 是一款强大的文件查重工具&#xff0c;可以帮助用户快速查找并删除重复的文件&#xff0c;节省存储空间并提高文件管理效率。该软件支持多种文件类型&#xff0c;包括图片、文档、音频、视…
阅读更多...
el-table 表格中插入表单循环校验

el-table 表格中插入表单循环校验

<template><div>{{form}}<el-form :model"form" ref"form"><el-form-item label"呃呃呃呃呃呃呃"><el-table :data"tableData" border><el-table-column prop"time" label"日期"…
阅读更多...
cookie、localStorage、sessionStorage 详解

cookie、localStorage、sessionStorage 详解

目录 cookie 是什么&#xff1f; cookie 不可以跨域请求 cookie 的属性 会话cookie & 永久性cookie cookie 禁用 cookie 的应用 sessionStorage 是什么&#xff1f; 失效时间 存储内容的类型 存储的大小 存储的位置 sessionStorage 的应用 localStorage 是什么…
阅读更多...
Linux内核架构和基础概念

Linux内核架构和基础概念

文章目录 前言 一、简述操作系统 二、宏内核和微内核 1.宏内核 2.微内核 3.Linux内核的特点 三&#xff0c;Linux内核架构 1.整体架构图 2.Linux子系统的划分 3.Linux子系统之间的关系 4.Linux内核目录介绍 总结 前言 随着Linux内核在全球市场份额的持续扩大&#xff0c;其影…
阅读更多...
使用WebClient发起网络请求

使用WebClient发起网络请求

目录 1、导入对应的pom 2、编写WebClientUtil请求工具类 3、使用WebClientUtil发起请求 使用WebClient的优点&#xff1a;支持lambdas 的函数&#xff1b;支持更高的并发性和更少的硬件资源&#xff1b;支持同步和异步&#xff1b;支持流式传输。具体的使用方式如下&#xff1a…
阅读更多...
Redis 特性，为什么要用Redis，Redis到底是多线程还是单线程

Redis 特性，为什么要用Redis，Redis到底是多线程还是单线程

一、Redis介绍 Redis&#xff08;Remote Dictionary Server )&#xff0c;即远程字典服务&#xff0c;是一个开源的&#xff0c;使用C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库&#xff0c;并提供多种语言的API。 二、特性(为什么要用Redis&#x…
阅读更多...
51单片机入门：定时器与中断系统

51单片机入门：定时器与中断系统

定时器的介绍 定时器&#xff1a;51单片机的定时器属于单片机的内部资源&#xff0c;其电路的设计连接和运转均在单片机内部完成。根据单片机内部的时钟或者外部的脉冲信号对寄存器中的数据加1&#xff0c;定时器实质就是加1计数器。因为又可以定时又可以计数&#xff0c;又称…
阅读更多...
最新文章

Copyright @ 2022~2023