【C++】vector及模拟实现

news2024/11/14 5:33:14
头像
🚀个人主页：奋斗的小羊
🚀所属专栏：C++
很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

目录

  • 💥1、vector的主要函数接口
  • 💥2、vector的模拟实现
    • 💥2.1 构造和析构
    • 💥2.2 vector属性相关函数
    • 💥2.3 运算符重载
      • 💥2.3.1 赋值重载
      • 💥2.3.2 [ ] 重载
    • 💥2.4 vector的打印
    • 💥2.5 扩容
      • 💥2.5.1 深拷贝中的浅拷贝问题
    • 💥2.6 迭代器失效的问题
      • 💥2.6.1 插入和删除
        • 💥扩容形成野指针
        • 💥挪动数据位置意义改变
    • 💥2.7 调整大小
  • 💥3、vector模拟实现完整代码

💥1、vector的主要函数接口

namespace yjz
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默认构造
		vector()
		{}

		//拷贝构造
		vector(const vector<T>& v)
		{}

		//迭代器区间构造
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{}
		//指定n个值构造
		vector(size_t n, const T& val = T())
		{}
		vector(int n, const T& val = T())
		{}

		//析构
		~vector()
		{}

		//交换数据
		void swap(vector<T>& tmp)
		{}

		//清理数据
		void clear()
		{}

		传统写法
		//vector<T>& operator=(const vector<T>& v)
		//{}

		//现代写法
		vector<T>& operator=(vector<T> tmp)
		{}
	
		size_t size() const
		{}
		size_t capacity() const
		{}

		//迭代器
		iterator begin()
		{}
		iterator end()
		{}
		const_iterator begin() const
		{}
		const_iterator end() const
		{}
		
		//【】重载
		T& operator[](size_t i)
		{}
		const T& operator[](size_t i) const
		{}

		//判空
		bool empty()
		{}

		//尾删
		void pop_back()
		{}

		//扩容
		void reserve(size_t n)
		{}
		
		//尾插
		void push_back(const T& n)//可能插入类等
		{}
		
		//插入
		iterator insert(iterator pos, const T& n)
		{}
		
		//删除
		iterator erase(iterator pos)
		{}
		
		//调整大小
		void resize(size_t n, T val = T())
		{}
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	template<class T>
	void print_vector(const vector<T>& v)
	{}
}

💥2、vector的模拟实现

💥2.1 构造和析构

  • 虽然vector使用编译器生成的默认构造就行，但是我们还需要写拷贝构造，有了构造函数编译器就不会生成默认构造了，所以可以在形式上写个默认构造
  • 类模版的成员函数，还可以继续是函数模版
//默认构造
vector()
{}

//拷贝构造
vector(const vector<T>& v)
{
	reserve(v.size());
	for (auto& e : v)
	{
		push_back(e);
	}
}

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

//指定n个值构造
vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}
vector(int n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

~vector()
{
	delete[] _start;
	_start = _finish = _end_of_storage = nullptr;
}

💥2.2 vector属性相关函数

size_t size() const
{
	return _finish - _start;
}
size_t capacity() const
{
	return _end_of_storage - _start;
}

//迭代器
iterator begin()
{
	return _start;
}
iterator end()
{
	return _finish;
}
const_iterator begin() const
{
	return _start;
}
const_iterator end() const
{
	return _finish;
}

💥2.3 运算符重载

💥2.3.1 赋值重载

  • 赋值重载可以借助swap函数，需要注意的是形参必须传值
void swap(vector<T>& tmp)
{
	std::swap(_start, tmp._start);
	std::swap(_finish, tmp._finish);
	std::swap(_end_of_storage, tmp._end_of_storage);
}

//现代写法
vector<T>& operator=(vector<T> tmp)
{
	swap(tmp);
	return *this;
}

💥2.3.2 [ ] 重载

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

💥2.4 vector的打印

为了方便打印vector中不同类型的数据，可以将迭代器遍历和范围for遍历封装成一个模版函数，有几点需要注意：

  • 模版参数只能给当前的函数或者类使用
  • 函数采用const引用传参，避免拷贝，迭代器也要保持一致使用const_iterator
  • 没有实例化的类模版里面取东西，编译器不能区分这里的const_iterator是类型还是静态成员变量，从属名称的使用必须以typename为前缀
  • 当然最省事的还是auto
template<class T>
void print_vector(const vector<T>& v)
{
	//typename vector<T>::const_iterator it = v.begin();
	auto it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

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

💥2.5 扩容

💥2.5.1 深拷贝中的浅拷贝问题

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* tmp = new T[n];
		memcpy(tmp, _start, sizeof(T) * size());
		delete[] _start;
		_start = tmp;
		//_finish = _start + size();
		_finish = _start + old_size;//_finish也要更新
		_end_of_storage = _start + n;
	}
}

上面是以前扩容的常规操作，但是在这里有些潜在的问题：

void test_vector7()
{
	vector<string> v1;
	v1.push_back("11111111111111");
	v1.push_back("11111111111111");
	v1.push_back("11111111111111");
	v1.push_back("11111111111111");

	print_vector(v1);
}

在这里插入图片描述

当我们在不扩容的情况下在vector中插入string类，不会出现什么问题，但如果扩容的话，就会出现问题：

在这里插入图片描述

这里的问题在扩容的过程中memcpy是按字节拷贝的（浅拷贝），而string类中还有_str指向一块空间，memcpy将string类中的所有数据都浅拷贝到tmp指向的空间中，tmp中的_str指向的还是原来的空间，释放旧空间时其中的string类会自动调用析构函数，释放掉_str指向的空间，最后tmp空间中的_str指向的就是非法空间。

在这里插入图片描述

要想解决这个问题也简单，用深拷贝来代替memcpy的浅拷贝，可以考虑赋值重载，因为 string类的赋值重载是深拷贝：

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* tmp = new T[n];
		//memcpy(tmp, _start, sizeof(T) * size());
		for (size_t i = 0; i < old_size; i++)
		{
			tmp[i] = _start[i];
		}
		delete[] _start;
		_start = tmp;
		//_finish = _start + size();
		_finish = _start + old_size;//_finish也要更新
		_end_of_storage = _start + n;
	}
}

💥2.6 迭代器失效的问题

💥2.6.1 插入和删除

💥扩容形成野指针

在指定位置插入一个数据，首先要判断vector是否满了，如果满了调用reserve扩容。插入前还需要挪动指定位置之后的数据，最后插入数据，++_finish。

void insert(iterator pos, const T& n)
{
    assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _end_of_storage)
	{
		reserve(capacity() == 0 ? 4 : 2 * capacity());
	}
	
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = n;
	++_finish;
}

这是常规的插入方法，和string类插入一个字符一样。但是当我们插入一个数据需要扩容时，编译运行就会陷入死循环。

在这里插入图片描述

原因是虽然扩容后_start、_finish、_end_of_storage都更新了，但是pos指向的还是原来的位置。
所以我们需要在扩容后将pos的指向也更新一下：

void insert(iterator pos, const T& n)
{	
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		pos = _start + len;
	}
	
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = n;
	++_finish;
}
💥挪动数据位置意义改变

假如我们想在某个数据前面插入但是不知道具体位置，则需要先查找到这个数据的地址：

int n;
cin >> n;
auto pos = find(v.begin(), v.end(), n);
if (pos != v.end())
{
	v.insert(pos, 40);
	*pos += 100;
}
print_vector(v);

请添加图片描述

如果没有扩容，pos原本指向的数据是我们要查找的3，但是在我们往3的前面插入一个40后，pos指向的数据就变了，这也被认为是迭代器失效；如果扩容，则就是上面讲的pos变成野指针。

  • 和vector类似，string在插入+扩容操作+erase后，迭代器也会失效
  • 所以不管扩不扩容， insert后pos就失效，不要直接访问，要访问就要更新迭代器的值。

可以在insert函数最后返回pos的值：

iterator insert(iterator pos, const T& n)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		pos = _start + len;
	}
	
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = n;
	++_finish;
	return pos;
}

int n;
cin >> n;
auto pos = find(v.begin(), v.end(), n);
if (pos != v.end())
{
	 pos = v.insert(pos, 40);
	*(p + 1) += 100;
}
print_vector(v);

同样的删除也会使迭代器失效：

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;
	return pos;
}
  • 删除vector中任意位置的数据，VS都认为该位置迭代器失效

💥2.7 调整大小

为了兼容类类型给缺省值的情况，内置类型也有了构造函数的概念。

请添加图片描述

void resize(size_t n, T val = T())
{
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		reserve(n);//大了才扩容
		while (_finish < _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
}

💥3、vector模拟实现完整代码

vector.h:

#pragma once

#include <iostream>
#include <assert.h>
#include <string>
using namespace std;

namespace yjz
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默认构造
		vector()
		{}

		//拷贝构造
		vector(const vector<T>& v)
		{
			reserve(v.size());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

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

		//指定n个值构造
		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		vector(int n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}

		void swap(vector<T>& tmp)
		{
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(_end_of_storage, tmp._end_of_storage);
		}

		void clear()
		{
			_finish = _start;
		}

		传统写法
		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		clear();
		//		reserve(v.size());
		//		for (auto e : v)
		//		{
		//			push_back(e);
		//		}
		//	}
		//}

		//现代写法
		vector<T>& operator=(vector<T> tmp)
		{
			swap(tmp);
			return *this;
		}
	
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		//迭代器
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}

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

		bool empty() const
		{
			return _start == _finish;
		}

		void pop_back()
		{
			assert(!empty());
			_finish--;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				T* tmp = new T[n];
				//memcpy(tmp, _start, sizeof(T) * size());
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
				_start = tmp;
				//_finish = _start + size();
				_finish = _start + old_size;//_finish也要更新
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& n)//可能插入类等
		{
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finish = n;
			++_finish;
		}

		iterator insert(iterator pos, const T& n)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + len;
			}
			
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = n;
			++_finish;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;
			return pos;
		}

		void resize(size_t n, T val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	template<class T>
	void print_vector(const vector<T>& v)
	{
		//typename vector<T>::const_iterator it = v.begin();
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

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

test.cpp:

#define  _CRT_SECURE_NO_WARNINGS

#include "vector.h"

namespace yjz
{
	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		print_vector(v);
	}

	void test_vector2()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		//v.push_back(5);

		print_vector(v);
		v.insert(v.begin() + 2, 10);
		print_vector(v);
	}

	void test_vector3()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		int n;
		cin >> n;
		auto pos = find(v.begin(), v.end(), n);
		if (pos != v.end())
		{
			pos = v.insert(pos, 40);
			*(pos + 1) += 100;
		}
		print_vector(v);
	}

	void test_vector4()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(4);

		print_vector(v);

		//删除所有的偶数
		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}
		
		print_vector(v);
	}

	void test_vector5()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		print_vector(v);

		v.resize(3);
		print_vector(v);
		v.resize(8, 1);
		print_vector(v);
	}

	void test_vector6()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		vector<int> v2(10, 1);
		print_vector(v2);
		vector<int> v3(v2.begin() + 1, v2.begin() + 5);
		print_vector(v3);

	}

	void test_vector7()
	{
		vector<string> v1;
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");

		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");
		v1.push_back("11111111111111");

		print_vector(v1);
	}
}

int main()
{
	//yjz::test_vector1();
	//yjz::test_vector2();
	//yjz::test_vector3();
	//yjz::test_vector4();
	//yjz::test_vector5();
	//yjz::test_vector6();
	yjz::test_vector7();
	return 0;
}

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

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

相关文章

Python 3 入门基础知识【1】数据类型 安装下载 推荐

Python 3 入门基础知识【1】数据类型 安装下载 推荐

Python的重要性这里不多说了&#xff0c;是一门面向对象的解释型语言&#xff0c;使用缩进作为逻辑层次&#xff0c;功能强大且容易上手&#xff0c;其受欢迎程度也在逐年上升的。这里回顾一下python的基础知识&#xff0c;以便自己查看&#xff0c;欢迎正在学习python的同学参…
阅读更多...
ArcGIS10.8 安装教程

ArcGIS10.8 安装教程

目录 一、环境及安装包准备 二、安装流程 1、解压安装包ArcGIS_108.rar 2、安装 三、汉化 四、激活 五、自定义菜单&#xff08;可选&#xff09; 六、打开软件按查看 七、安装过程中出现的报错 八、其他 一、环境及安装包准备 安装环境&#xff1a;win7 安装包下载…
阅读更多...
[FBCTF2019]RCEService1

[FBCTF2019]RCEService1

打开题目 它给出了提示要求json格式&#xff0c;先尝试一下{"cmd":"ls"} 的确可以执行。接下来就记录过滤了那些关键字。发现键盘上有的特殊符号好像都被过滤。 flag在home目录下&#xff0c;不知道为什么find命令返回为空。。。 cat在这里仍然不能用。…
阅读更多...
go语言后端开发学习(六) ——基于雪花算法生成用户ID

go语言后端开发学习(六) ——基于雪花算法生成用户ID

前言 在我们日常进行开发的时候,不可避免的会出现对用户表的操作&#xff0c;而为了保证每一个用户的唯一性&#xff0c;这就需要我们创建一个唯一性的id&#xff0c;但是现在有一个问题&#xff0c;如果我们仅仅像通过自增这样方式来创建唯一的id&#xff0c;这无疑是非常不合…
阅读更多...
第N5周：Pytorch文本分类入门

第N5周：Pytorch文本分类入门

本文为365天深度学习训练营 中的学习记录博客原作者&#xff1a;K同学啊 任务&#xff1a; ●1. 了解文本分类的基本流程 ●2. 学习常用数据清洗方法 ●3. 学习如何使用jieba实现英文分词 ●4. 学习如何构建文本向量 一、前期准备 环境安装 这是一个使用PyTorch实现的简单文…
阅读更多...
超详细教程：贴片电阻要怎么焊接？

超详细教程：贴片电阻要怎么焊接？

在电子硬件中&#xff0c;焊接是必不可少的一个技能。 但是在实际的学习或者工作过程中&#xff0c;往往会碰上各种各样的焊接条件&#xff0c;焊接环境&#xff0c;如果是对于直插式的元件&#xff0c;比如说焊接一个直插式LED灯或者直插式电解电容&#xff0c;可能很容易焊接…
阅读更多...
15个网络工程师必须记住的专业术语和概念

15个网络工程师必须记住的专业术语和概念

网络工程师在日常工作中确实需要掌握大量的专业术语和概念&#xff0c;这些术语和概念是理解和应用网络技术的基础。以下是一些网络工程师必知的重要术语及其应用场景&#xff1a; 1. IP地址&#xff08;IP Address&#xff09; 定义&#xff1a;互联网协议地址&#xff0c;用…
阅读更多...
Elasticsearch 8 RAG 技术分享

Elasticsearch 8 RAG 技术分享

作者&#xff1a;来自 Elastic 中国区首席架构师 Jerry 本文由 Elastic 中国区首席架构师 Jerry Zhu 在【AI 搜索 TechDay】上的分享整理而成。【AI 搜索 TechDay】 是 Elastic 和阿里云联合主办的 AI 技术 Meetup 系列&#xff0c;聚焦企业级 AI 搜索应用和开发者动手实践&am…
阅读更多...
企业信息化建设搞得好了叫系统工程，搞不好叫面子工程

企业信息化建设搞得好了叫系统工程，搞不好叫面子工程

2024-06-13 09:26贝格前端工场
阅读更多...
framebuffer总结

framebuffer总结

FrameBuffer&#xff0c;可以译作"帧缓冲"&#xff0c;有时简称为 fbdrv。 这是一种独立于硬件的抽象图形设备。 是Linux为显示设备提供的一个接口&#xff0c;把显存抽象后的一种设备&#xff0c; 允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作 什么是…
阅读更多...
QT 网络聊天室简易版

QT 网络聊天室简易版

视频:qt开发网络聊天w室软件3.4界面开发_哔哩哔哩_bilibili 目录 UI部分 设计稿图 放置控件 界面美化 拖动窗体 设置界面 网络部分 配置对话框 多项目结果和服务器端设计 客户端框架开发 UI部分 设计稿图 放置控件 界面美化 现在我们把窗体自带的标题栏给去了,用我们自…
阅读更多...
软件设计之MySQL(1)

软件设计之MySQL(1)

软件设计之MySQL(1) 此篇应在JavaSE之后进行学习: 路线图推荐&#xff1a; 【Java学习路线-极速版】【Java架构师技术图谱】 Navicat可以在软件管家下载 使用navicat连接mysql数据库创建数据库、表、转储sql文件&#xff0c;导入sql数据 学习内容&#xff1a; 数据库概述表、…
阅读更多...
6.IIC

6.IIC

理论 参考51单片机IIC理论&#xff1a;链接 在起始信号后必须发送一个7位从机地址 1位方向位&#xff0c;用“0”表示主机发送数据&#xff0c;“1”表示主机接收数据 代码编写 IIC三个模式配置 IIC(阻塞模式)配置 主要方式 IIC(中断模式)配置 IIC(DMA模式)配置 阻塞模式 mi…
阅读更多...
智源研究院举办第一期数据与行业应用Workshop

智源研究院举办第一期数据与行业应用Workshop

近日&#xff0c;北京智源人工智能研究院联合中国互联网协会人工智能工委会、中国AIIA联盟数据委员会、CSDN举办了以“行业革新&#xff0c;数据先行”为主题的第一期数据与行业应用Workshop。来自智源研究院、中国信息通信研究院、航天信息技术有限公司、北京市科学技术研究院…
阅读更多...
学习记录第二十七天

学习记录第二十七天

进程 wait函数 功能 等待子进程结束&#xff1a;父进程调用wait函数后&#xff0c;会暂停执行&#xff0c;直到它的某个子进程结束。收集子进程状态&#xff1a;当子进程结束时&#xff0c;wait函数会返回子进程的终止状态&#xff0c;包括是正常终止还是被信号终止等信息。…
阅读更多...
单链表leetcode刷题/中（C语言版）

单链表leetcode刷题/中（C语言版）

目录 题目1&#xff1a;合并两个有序链表 题目2&#xff1a;分割链表 题目3&#xff1a;随机链表的复制 “单链表leetcode刷题/上”的链接&#xff1a;https://blog.csdn.net/2302_80297338/article/details/140409360?spm1001.2014.3001.5501 题目1&#xff1a;合并两个有…
阅读更多...
Ecovadis认证评估的四个方面 Ecovadis评估结果呈现形式

Ecovadis认证评估的四个方面 Ecovadis评估结果呈现形式

Ecovadis的认证过程严谨&#xff0c;基于国际公认的标准和准则进行评估。获得Ecovadis认证的企业&#xff0c;在社会责任、环境保护、商业道德和可持续采购等方面的表现得到了专业认可&#xff0c;这有助于提升企业的信誉度和透明度&#xff0c;增强利益相关者的信任。 Ecovad…
阅读更多...
【CTF | WEB】003、攻防世界WEB题目之xff_referer

【CTF | WEB】003、攻防世界WEB题目之xff_referer

文章目录 xff_referer题目描述:解题思路&#xff1a;XFF与Referer基本了解1. XFF&#xff08;X-Forwarded-For&#xff09;&#xff1a;2. Referer&#xff1a;简单总结&#xff1a; 解题实操&#xff1a; xff_referer 题目描述: X老师告诉小宁其实xff和referer是可以伪造的。…
阅读更多...
在 Linux 系统中下载 Python 并配置环境

在 Linux 系统中下载 Python 并配置环境

哈喽&#xff0c;大家好&#xff0c;木易巷来啦&#xff01; 在 Linux 系统中下载 Python 并配置环境&#xff0c;主要包含以下几个核心步骤&#xff1a; ▍1、安装 Python 多数 Linux 发行版已预装 Python&#xff0c;但您可能需要安装不同版本或更新现有版本。 打开终端。 …
阅读更多...
SpringBoot(Ⅰ)——HelloWorld和基本打包部署+Pom依赖概述+@SpringBootApplication注解+自动装配原理+约定大于配置

SpringBoot(Ⅰ)——HelloWorld和基本打包部署+Pom依赖概述+@SpringBootApplication注解+自动装配原理+约定大于配置

前言 如果SSM学的比较好&#xff0c;那么SpringBoot说白了就两件事:约定大于配置和自动装配 SpringBoot不会提供任何的功能拓展&#xff0c;完全依赖我们手动添加 所以SpringBoot的本质是一个依赖脚手架&#xff0c;可以快速集成配置各种依赖 1.1 SpringBoot相关依赖 创建…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023