String模拟实现(二）

news2024/10/7 14:32:38

resize

resize的特点是扩容加初始化，如果所给的长度小于空间大小就会删除多余的数据。前面我们实现了reserve，但有这样一个问题，如果reserve的长度小于空间就会导致缩容，而我们知道，string中缩容用的是shrink_to_fit，而reserve并不会导致缩容。

测试：

size_t capacity()const
		{
			return _capacity;
		}

 可以看到出现了容量小于size的情况，这样在拷贝的时候就会越界并在析构时出错，我们加上判断就可以了。

void reserve(size_t n)
		{
			if (n > _size)
			{
				char* tmp = new char[n + 1];

				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

 

对比reserve，它们的共同点都是不对capacity产生影响，这种以时间换空间的做法会增加对资源的消耗，除此之外，resize的初始化分三种情况：

n<size

size<n<capacity

n>size

我们实现前先看段代码：

 这段代码说明了什么问题呢？

答：resize的初始化是在原有数据的基础上初始化的，之所以举这个例子是因为不给第二个参数会默认给\0初始化，通过调试可以发现前10个数据其实是\0，希望大家能注意这一点。

我们可以用memset和遍历的方式初始化，当然不要忘了补上\0

void resize(size_t n, char ch = '\0')
		{
			if (n <= _size)
			{
				_size = n;
				_str[n] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);//复用
				}
				memset(_str + _size, ch, n - _size);
				/*size_t i = _size;
				while (i < n)
				{
					_str[i] = ch;
					i++;
				}*/
				_size = n;
				_str[_size] = '\0';
			}

 insert

插入接口分三个部分：
判断扩容

移动数据

插入并更正size

先看看插入单个字符 

void insert(size_t pos, char ch)
		{
			assert(pos <= _size);// '\0'可以插
				if (_size+1>_capacity)
				{
					reserve(_capacity * 2);//知道每次进多少数据
				}
				size_t end = _size;
				while (end >= pos)
				{
					_str[end + 1] = _str[end];
					--end;
				}
				_str[pos] = ch;
				++_size;
		}

测试数据：

	s1.insert(0,'x');

为什么呢？

原来我们用的是无符号整形，当end变为0时再进入循环并自减就会来到-1(整形的最大值),这样就会导致又进入循环发生不可预知的错误。

那我们将无符号改为int不就行了吗？

理论上是可以的，但是这样做不符合库的规范。如果仅让end变为int也不行，编译器在对两个不同类型数据进行判断时，会进行隐式转换，而unsigned int与int比较会转换为两个unsigned int的比较，所以依然不行。

那该怎么做呢？

既然是end出了问题，就重源头下手，不要老想着加判断或分开处理这样的方式，这是一种牺牲可读性的做法，后期维护时可能会一头雾水。

 误删了一大段代码发现程序还能跑起来，这个时候我们一定不要动它

                size_t end = _size + 1;
				while (end > pos)
				{
					_str[end] = _str[end-1];
					--end;
				}

库里面的接口是这样写的：

string& insert (size_t pos, size_t n, char c);

一般我们只插入单个字符，所以想要插入多个字符串，我们可以通过下面的接口实现。

void insert(size_t pos, const char* s)

		{
			assert(pos <= _size);
			size_t len = strlen(s);
			if (_size + len > _capacity)//扩容
			{
				reserve(_size + len);
			}
			size_t end = _size+len;
			while (end > len+pos -1)
			{
				_str[end] = _str[end -len];
				end--;
			}
			strncpy(_str + pos, s, len);//不拷贝\0
            _size += len;
		}

这里需要减1比较难以理解，可以假设当pos＝_size时，无法进入循环体移动\0位置，最终导致被覆盖出错。不用>=判断是因为如果变量都为0可能会造成刚才为负数的情况，这种判断条件最多是右边为负数，由于无符号的特性，此时跳出循环，相当于什么都不做，符合逻辑。 

 对之前的尾插函数复用 

        void push_back(char ch)
		{
			insert(_size, ch);
		}
		void append(const char* s)
		{
			insert(_size, s);
		}

测试结果：

erase

介绍erase之前我们先来看看如何定义缺省npos

npos是一个静态常量成员函数，而静态成员函数是在类外初始化的

private:
static const size_t npos;
//内外
const size_t string::npos = -1;

需要知道的是，对于静态常整形，可以在类里指定一个缺省值

		static const size_t n = -1;

可以看到，删除数据有三种情况，但可以归为两类：部分删除和删除指定位置之后的所有数据

	string& erase(size_t pos, size_t len = npos)
		{
       		assert(pos <= _size);
			if (len == npos || pos + len >= _size)//全删
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);//部分删
					_size -= len;
			}
            return *this;//可以返回可以不返回
		}

注意这里判断len==pos的理由是如果用npos+pos可能会导致值溢出，这样就会重置其值可能导致判断错误。 

测试结果：

swap

void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_capacity,s._capacity);
			std::swap(_size,s._size);
		}

从这一点看出来使用string类的swap效率是远远高于库里的swap的，std::swap需要创建临时对象，实现三次深拷贝，而string::swap只需对三个内置类型的成员变量进行交换就可以了。 

find

对于单个查找我们可以这样实现：

size_t find(char ch, size_t pos = 0) const//单个查找
		{
			assert(pos < _size);
				for (size_t i = pos; i < _size; i++)
				{
					if (_str[i] == ch)
					{
						return i;
					}
				}
		}

查找字符串我们可以用strstr函数进行查找 

 strstr的查找规则是如果找到就用指针返回第一个出现的下标，负责返回空指针。

	size_t find(const char* s, size_t pos = 0)const//字串
		{
			assert(pos < _size);
			char* ptr = strstr(_str + pos, s);
		if (ptr!=nullptr)
			{
				return ptr	- _str;//位移量
			}
			else return npos;//find不匹配返回npos
		}

cout&&cin

cout

与c_str不同，cout是打印string中的size个数据，他不会遇到\0就终止打印。

还有一点，不是所有cout重载都要变成友元，如果实现了对应获取成员变量的函数则无需添加友元，保护其封装性。

std::ostream& operator<<(std::ostream& out,const string& s)
	{
		for (auto ch : s)//实现了begin()和end()
		{
			out << ch;
		}
	/*	for (size_t i = 0; i <s.size(); i++)
		{
			out << s[i];
		}*/
		return out;
	}
}

( 这里用std::和自己实现的结果一样)注意这里用'\0'和"\0"所表达意思完全不同，单引号是解析成一个字符常量(占用1size空间)，双引号为字符串结束标志，在我们附加world的时候用双引号作为结束标志则会被覆盖掉(没有意义)。可以在world前加\0使其只输出hello。而c语言风格的不做区别，有\0直接停止输出。

结论：当\0作为字符常量时，cout输出size大小的数据

cin

std::istream& operator>>(std::istream& in,string& s)
	{
		char ch;
		in >> ch;
		while (ch != ' ' && ch != '\n')
		{
			s+=ch;
			in >> ch;
		}
		return in;
	}

上面的程序可以运行，但是无法结束循环，这是为什么呢？

cin作为流提取，会将空格和换行符等一些空白字符当作间隔符区分不同数据，所以并不会读取它们。为了读取这两种字符，我们可以使用istream中的get函数

	char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s+=ch;
			ch = in.get();
		}
		return in;

除此之外，我们还需要用一个清理函数清理上一次输入的值

void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

对于输入一个很大的数据，我们可以提前开好空间来减少扩容

我们可以创建一个局部变量buff来储存数据，由于是手动输入数据，用这样的方式相比reserve更加灵活(出了作用域自动销毁）。

std::istream& operator>>(std::istream& in,string& s)
	{
		s.clear();
		char ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
			if (i != 0)
			{
				buff[i] = '\0';
				s += buff;
			}
		}
		return in;
	}

这里buff终止位置加\0是为了添加到数组的时候不至于越界。

string大小

private:
		 char* _str;
		size_t _size;
		size_t _capacity;

在vs环境下，模拟实现的string只有12字节，而库里的string存在一个_buf数组存储16个空间，之前我们在讲string时也说过，这样空间换时间的做法提高了程序的效率。

string.h完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;
namespace zzl
{
	class string
	{
	public:
		//string()
		//	:_str(new char[1])//匹配析构
		//	,_size(0)
		//	,_capacity(0)
		//{
		//	_str[0] = '\0';
		//}
		string(const char* str = "\0")//""也可以
			:_size(strlen(str))
		{
			_capacity = _size==0? 3:_size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
			_capacity = _size = 0;
		}
		string(const string& s)
			:_size(s._size)
			,_capacity(s._capacity)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}
		void swap(string& s)//交换
		{
			std::swap(_str, s._str);
			std::swap(_capacity,s._capacity);
			std::swap(_size,s._size);
		}
		size_t find(char ch, size_t pos = 0) const//单个查找
		{
			assert(pos < _size);
				for (size_t i = pos; i < _size; i++)
				{
					if (_str[i] == ch)
					{
						return i;
					}
				}
		}
		size_t find(const char* s, size_t pos = 0)const//字串
		{
			assert(pos < _size);
			char* ptr = strstr(_str + pos, s);
			if (ptr!=nullptr)
			{
				return ptr	- _str;//位移量
			}
			else return npos;//find不匹配返回npos
		}
		const char* c_str()const//外部不加const，指针可以改变
		{
			return _str;//返回常量字符串
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);//\0不存有效数据
			return _str[pos];
		}
		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;//指向堆区
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}
		size_t size()const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}
		//模拟迭代器打印
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str+size();
		}
		//const
		const_iterator begin()const
		{
			return _str;
		}
		const_iterator end()const
		{
			return _str + size();
		}
		void Print(const string& s)const
		{
			for (int i = 0; i < s.size(); i++)
			{
				cout << s[i] << " ";
			}
			cout << endl;
			for (auto& ch : s)//const
			{
				cout<< ch << ' ';
			}
			cout << endl;
		}
		bool operator==(const string& s)const
		{
			return !strcmp(_str, s._str);
			//return strcmp(_str, s._str) == 0;
		}
		bool operator>(const string& s) const
		{
			return strcmp(_str, s._str) > 0;
		}
		bool operator>=(const string& s) const
		{
			//return *this > s || *this == s;
			return *this > s || s == *this;
		}

		bool operator<(const string& s) const
		{
			return !(*this >= s);
		}

		bool operator<=(const string& s) const
		{
			return !(*this > s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}
		//扩容
		void reserve(size_t n)
		{
			if (n > _size)
			{
				char* tmp = new char[n + 1];

				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void resize(size_t n, char ch = '\0')
		{
			if (n <= _size)
			{
				_size = n;
				_str[n] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);//复用
				}
				memset(_str + _size, ch, n - _size);
				/*size_t i = _size;
				while (i < n)
				{
					_str[i] = ch;
					i++;
				}*/
				_size = n;
				_str[_size] = '\0';
			}
				
			
		}
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);// '\0'可以插
				if (_size+1>_capacity)
				{
					reserve(_capacity * 2);//注意capacity不能为0(构造已给初始值)
				}
				size_t end = _size + 1;
				while (end > pos)
				{
					_str[end] = _str[end-1];
					--end;
				}
				_str[pos] = ch;
				++_size;
		}
		void insert(size_t pos, const char* s)

		{
			assert(pos <= _size);
			size_t len = strlen(s);
			if (_size + len > _capacity)//扩容
			{
				reserve(_size + len);
			}
			size_t end = _size+len;
			while (end > len+pos -1)//涉及\0的移动
			{
				_str[end] = _str[end -len];
				end--;
			}
			strncpy(_str + pos, s, len);//不拷贝\0
			_size += len;
		}
		void erase(size_t pos, size_t len = npos)
		{
			assert(pos <= _size);
			if (len == npos || pos + len >= _size)//全删
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);//部分删
					_size -= len;
			}
		}
		void push_back(char ch)
		{
			//if (_size + 1 > _capacity)
			//{
	
			//	reserve(_capacity == 0 ? 3: _capacity * 2);//复用
			//}
			//_str[_size] = ch;//\0处插入
			//_size++;
			//_str[_size] = '\0';
			insert(_size, ch);
		}
		void append(const char* s)
		{
			/*int len = strlen(s);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, s);
			_size += len;*/
			insert(_size, s);
		}
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		string& operator+=(const char* s)
		{
			append(s);
			return *this;
		}
		void clear()
		{
			_str[0] = '\0';
			_size = 0;//一般不缩容
		}
	private:
		 char* _str;
		size_t _size;
		size_t _capacity;

		static const size_t npos;
		//static const size_t n = -1;
	};
	const size_t string::npos = -1;
	std::ostream& operator<<(std::ostream& out,const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		/*for (size_t i = 0; i <s.size(); i++)
		{
			out << s[i];
		}*/
		return out;
	}
	std::istream& operator>>(std::istream& in,string& s)
	{
		s.clear();
		char ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
			if (i != 0)
			{
				buff[i] = '\0';
				s += buff;
			}
		}
		return in;
	}
}

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

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

相关文章

外观设计模式解读

外观设计模式解读

目录 问题引进 传统方式解决影院管理 外观模式基本介绍 概念 外观模式原理类图 分类外观模式的角色 外观模式解决影院管理 传统方式解决影院管理说明 外观模式应用实例 外观模式的注意事项和细节 s统的内部细节 > 外观模式 外观模式基本介绍 概念 1) 外观模式&…
阅读更多...
XGBoost的介绍

XGBoost的介绍

一、XGBoost的介绍 1.什么是XGBoost&#xff1f; XGBoost&#xff08;eXtreme Gradient Boosting&#xff09;是一种基于梯度提升树的机器学习算法&#xff0c;它在解决分类和回归问题上表现出色。它是由陈天奇在2014年开发的&#xff0c;如今已成为机器学习领域中最流行和强…
阅读更多...
集合框架知识汇总

集合框架知识汇总

集合框架 集合 概念&#xff1a;对象的容器&#xff0c;定义了对多个对象进行操作的常用方法。可以实现数组功能 和数组的区别 数组长度固定&#xff0c;集合长度不固定 数组可以存储基本类型和引用类型&#xff0c;集合只能存储引用类型 总结 List集合 有序&#xff0c;有…
阅读更多...
软考网工易混淆知识点总结（持续更新中，按照知识点先后排序）

软考网工易混淆知识点总结（持续更新中，按照知识点先后排序）

1.数据编码--原码、反码和补码 原码 数值前面增加了一位符号位(即最高位为符号位)&#xff0c;该位为0时表示正数&#xff0c;为1时则表示负数&#xff0c;其余各位表示数值的大小反码 正数的反码与原码相同&#xff0c;负数的反码符号位为1&#xff0c;其余各位为该数绝对值的…
阅读更多...
大型语言模(LLM) : 提示词工程(一)

大型语言模(LLM) : 提示词工程(一)

今天我学习了DeepLearning.AI的 Prompt Engineering 的在线课程&#xff0c;我想和大家一起分享一下该门课程的一些主要内容。 下面是我们访问大型语言模(LLM)的主要代码&#xff1a; import openaiopenai.api_key XXXXXXXXXdef get_completion(prompt, model"gpt-3.5-…
阅读更多...
高性能分布式API网关Kong

高性能分布式API网关Kong

目录 1 kong网关简介2 为什么需要 API 网关2.1 和Spring Cloud Gateway区别 3 为什么要使用kong3.1 kong的组成部分3.2 Kong网关的特性 4 kong网关架构4.1 Kong网关请求流程 5 kong 部署5.1 搭建网络5.2 搭建数据库环境5.3 kong网关部署5.3.1 初始化kong数据5.3.2 启动Kong容器…
阅读更多...
【项目】树莓派4B镜像安装

【项目】树莓派4B镜像安装

本文主要记录下如何使用Raspberry Pi image 软件进行树莓派镜像进行安装。 官网&#xff1a;Raspberry Pi OS – Raspberry Pi 百度网盘&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1G7z1Fdvk5Chmhj894WPU3A 提取码&#xff1a;xnzw 一、格式化SD卡 若SD卡存在…
阅读更多...
释放潜能——解读新时代OEM竞争规则，打造精雕细琢的用户体验

释放潜能——解读新时代OEM竞争规则，打造精雕细琢的用户体验

从消费零售全领域的实践观察来看&#xff0c;仅仅凭借产品赢得竞争的时代已经过去&#xff0c;商业模式创新体现在越来越多企业向“产品服务”转变&#xff0c;向用户全生命周期需求挖掘转变。企业与消费者之间的关系从过去的一次性、断点式产品交易&#xff0c;转向持续性、覆…
阅读更多...
读写ini配置文件（C++）

读写ini配置文件（C++）

文章目录 1、为什么要使用ini或者其它(例如xml,json)配置文件&#xff1f;2、ini文件基本介绍3、ini配置文件的格式4、C读写ini配置文件5、 代码示例6、 配置文件的解析库 文章转载于&#xff1a;https://blog.csdn.net/weixin_44517656/article/details/109014236 1、为什么要…
阅读更多...
基于 Web 和 Deep Zoom 的高分辨率大图查看器的实践

基于 Web 和 Deep Zoom 的高分辨率大图查看器的实践

基于 Web 和 Deep Zoom 的高分辨率大图查看器的实践 高分辨率大图像在 Web 中查看可以使用 Deep Zoom 技术&#xff0c;这是一种用于查看和浏览大型高分辨率图像的技术&#xff0c;它可以让用户以交互方式浏览高分辨率大图像&#xff0c;并且能够在不影响图像质量的情况下进行…
阅读更多...
搭建个人网站 保姆级教程（四）Navicat链接mySql 失败

搭建个人网站 保姆级教程（四）Navicat链接mySql 失败

长时间没有折腾云服务器上的mysql了&#xff0c;今天再次使用Navicat连接云服务器上的mysql时&#xff0c;输入密码报错&#xff01; 1130 - Host ‘119.130.212.168’ is not allowed to connect to this MySQL server 1.于是Royal TSX 远程服务器查看mysql的状态 systemctl …
阅读更多...
通达信标记文字中可能用到的特殊符号大全

通达信标记文字中可能用到的特殊符号大全

特殊符号是难以直接输入的符号&#xff0c;特殊符号是符号的一种&#xff0c;比如说圆圈&#xff08;〇&#xff09;、叉号&#xff08;✕、✖、✘&#xff09;、五角星&#xff08;★、☆&#xff09;、勾号&#xff08;✓、✔&#xff09; 。 01.特殊符号简表 ♠♣♧♡♥❤…
阅读更多...
chatgpt赋能python：Python强制取整：如何在Python中正确进行取整操作

chatgpt赋能python：Python强制取整：如何在Python中正确进行取整操作

Python强制取整&#xff1a;如何在Python中正确进行取整操作 Python是一种广泛使用的编程语言&#xff0c;有许多不同的用途&#xff0c;包括数据分析、web开发、机器学习、科学计算等等。Python语言非常容易学习和使用&#xff0c;但有时候它的行为可能会出人意料&#xff0c…
阅读更多...
alpa概览

alpa概览

文章目录 背景alpa简介DeviceMesh跨 DeviceMeshes 的 GPU Buffer管理Ray CollectivePipeline parallelism runtime orchestration运行时 背景 LLM训练有3D并行的需求&#xff08;alpa将数据并行视为张量并行&#xff0c;即张量沿batch切分&#xff09; 算子间并行的通信成本小…
阅读更多...
【Vue】父子组件传参 孙子调用爷爷的方法 provide inject

【Vue】父子组件传参 孙子调用爷爷的方法 provide inject

一. 父传子 父组件先在data中定义要传给子组件的属性名父组件在中引入子组件在components中注册使用步骤 3 中注册好的子组件在 3 中&#xff0c;父传子 &#xff08;1&#xff09;利用 : 将父组件的对象、数组、字符串等传给子组件&#xff0c;供子组件使用 &#xff08;2&am…
阅读更多...
Rocky Linux9安装教程

Rocky Linux9安装教程

序言 Centos废了&#xff0c;最近在考虑将服务器迁移至Rockylinux系统&#xff0c;在这里记录下安装过程 当前安装版本RockyLinux9.2&#xff08;minimal版本&#xff09;&#xff0c;VMware Fusion专业版13.0.2 创建虚拟机 第一步&#xff1a; 先下载好ISO文件&#xff0c…
阅读更多...
python-高级特性

python-高级特性

文章目录 1.生成式2.生成器3.闭包4.装饰器&#xff08;1&#xff09;万能装饰器的实现&#xff08;2&#xff09;含参数的装饰器&#xff08;3&#xff09;多装饰器 5.内置高阶函数 1.生成式 列表生成式就是一个用来生成列表的特定语法形式的表达式。是Python提供的一种生成列表…
阅读更多...
2023.6.7小记——什么是FPGA？

2023.6.7小记——什么是FPGA？

最近打算开始继续做一些个人分享&#xff0c;已经太久时间没有写文章了&#xff0c;感觉这样下去肯定不是个好事&#xff0c;当程序员当然是要保持分享~ 标题就暂时先以每天我认为最重要的一点来取&#xff0c;内容不仅限于此。 1. 什么是FPGA&#xff1f; 全称是Field-Progra…
阅读更多...
PCL 点云均值漂移算法（MeanShift）

PCL 点云均值漂移算法（MeanShift）

文章目录 一、简介二、实现代码三、实现效果参考资料一、简介 均值漂移算法是一种非常经典的层次聚类方式，已在二维图像中得到了广泛的应用。这里我们也已二维图像为例来阐述其整个计算过程： 算法基本思想：如下图所示，左侧为实际的图像特征的分布，右侧为基于图像特征分布计…
阅读更多...
Linux操作系统——第二章 进程控制

Linux操作系统——第二章 进程控制

目录 进程创建 fork函数初识 fork函数返回值 写时拷贝 fork常规用法 fork调用失败的原因 进程终止 进程退出场景 进程常见退出方法 _exit函数 exit函数 return退出 进程等待 进程等待必要性 进程等待的方法 wait方法 waitpid方法 获取子进程status 进程程序…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023