C/C++ string模拟实现

news2024/10/6 16:17:21

1.模拟准备

1.1因为是模拟string，防止与库发生冲突，所以需要命名空间namespace隔离一下，我们来看一下基本内容

namespace yx
{
	class string
	{

	private:
		//char _buff[16];  lunix下小于16字节就存buff里

		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

1.2我们这里声明和定义分离，分为string.h和string.cpp

最简单的是：把声明和定义都往命名空间里包就可以

        

2.模拟实现

2.1遇到一个类，先来写构造和析构

构造和析构

我们来看一下下面代码对不对

namespace yx
{ 
	string::string(const char* str)
		:_str(str)
	{

	}
}

既然这么问了，那肯定是不对的，

因为你初始化string的时候，可能为常量字符串初始化的，它是不可以作为初始化对象的，当你扩容、修改就没法改了

yx::string s1("hello world");

应该这样玩：

namespace yx
{ 
	string::string(const char* str)
		:_str(new char[strlen(str) + 1])
	{

	}
}

我和你开一样的空间

完整写法👇 

string::string(const char* str)
	:_str(new char[strlen(str) + 1])
	, _size(strlen(str))
	, _capacity(strlen(str))
{
	strcpy(_str, str);
}

但还是有点问题的，strlen的效率还是有点底的，它和sizeof不一样，sizeof是在编译时运行，根据存储规则，内存对齐规则来算，strlen是运行时算的，三个strlen就重复运算了。

我们可以把size放在初始化列表，把其他的放在函数体初始化

string::string(const char* str)
	: _size(strlen(str))
{
	_str = new char[_size + 1];
	_capacity = _size;
	strcpy(_str, str);
}

这是比较传统的写法，我们来看一下同样手法

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

创建一个临时变量tmp，s1给给tmp，然后把s2指向tmp，tmp指向s2的位置.

c_str

const char* c_str() const;
const char* string::c_str() const
{
	return _str;
}

加const是为了让const或非const成员都能访问到，c_str()的类型为const char*,相当于常量字符串，遇到\0就会停止

无参string

我们可不可以这样写呢？

string::string()
{
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}

看起来可以，但实际不可以，这里的delete和free是不会出问题的，因为delete是可以空指针的

我们看例子，后定义的先析构，程序崩溃了，为什么呢？

c_str ，类型为const char* 不会按指针打印，是常量字符串，就会解引用找到\0才停止。

但库里不会崩溃

为什么？

因为这个地方不是没有空间，库里面开了一个空间

所以初始化要改为

string::string()
{
	_str = new char[1] {'\0'};
	_size = 0;
	_capacity = 0;
}

new一个空间，而实践中不会这样写，无参的和带参的是可以和成一个的，就是全缺省

如下👇，冒号里的\0是可以不写的 默认就是\0 , 给的是字符串

namespace yx
{
	class string
	{
	public:
		//string(); //无参构造  
		string(const char* str = "\0");
		~string();
		const char* c_str() const;//加上const，const成员和非const成员都可以调用


	private:
		//char _buff[16];  lunix下小于16字节就存buff里

		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

遍历：运算符重载[] 和 size()

char& string::operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}
size_t string::size() const
{
	return _size;
}

测试：可读可写

迭代器：begin 和 end

实现方式有两种，自定义类型的和简单点的，我们这里使用简单的

typedef char* iterator;

iterator begin();
iterator end();
string::iterator string::begin()
{
	return _str;
}
string::iterator string::end()
{
	return _str + _size;
}

为什么这样写？

注：

        这里必须用typedef，为什么？迭代器体现的是一种封装

        这里的typedef相当于把char*用iterator封装起来，而且这里的迭代器一定是char*吗，在lunix下是char*吗，不同平台是不同的。

把不同类型，不同平台的类型都封装成Iterator，隐藏的底层的细节。它是一个像指针的东西。iterator的原生类型是不确定的，给了一种简单通用访问容器的方式。

无论哪个容器都重命名为iterator，各个类域也不会发生冲突。

const迭代器

定义及实现

const_iterator begin() const;
const_iterator end() const;
string::const_iterator string::begin() const
{
	return _str;
}

这里可以直接返回_str，_str类型为char*，begin为const char* ，相当于权限缩小。

string::const_iterator string::end() const
{
	return _str + _size;
}

这里也是权限缩小，下面我们测试一下

测试成功，而且是不能给常量赋值的，如下👇

如果我们用方括号加size来遍历呢？

这里会报错，为啥？因为s3是常量，所以还需要重载一个const修饰的operator[]

const char& operator[](size_t pos) const;

​
const char& string::operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

测试通过。

push_back()  、 append()  和 reserve()

完成了string的基本功能，下面我们来进行string的插入。

push_back()是尾插一个字符，append()插入一个字符串，这里我们会遇到一个问题，push_back()尾插扩容一倍或两倍，不会太大；append()是插入一个字符串，有可能需要扩容，但扩容多少呢？插入字符串长短不定，万一非常长，你扩容二倍？显然扩容多少倍是不确定的。这里我们引入reserve().

reserve()请求保留空间，一般不会缩容，如果空间比capacity大了就会扩容

void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];//为什么预留一个空间？ 因为\0是不算在里面的
		strcpy(tmp,_str);
		delete[] _str;//释放旧空间

		_str = tmp;//指向新空间
		_capacity = n;
	}
}

push_back()

​
void string::push_back(char ch)//插入字符
{
	if (_size == _capacity)//如果size 等于 容量大小才会扩容
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);//传给reserve，如果比当前capacity大，就扩容
	}

	_str[_size] = ch;//_size是最后一个字符的下一个位置
	_str[_size + 1] = '\0';
	++_size;
}

​

满足扩容条件才扩容，_size是最后一个字符的下一个位置，也就是\0的位置，所以需要把\0也处理一下。

append()

我们来看一下下面代码正确否？

void string::append(const char* str)//插入字符串
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);//现在有_size个，我们需要插入长度为len的字符串
	}
	strcat(_str, str);
	_size += len;
}

使用了strcat()，直接在原字符串后面追加，我们测试一下

测试没问题。但是我们用strcat的时候要谨慎一些，他会从头开始找\0，效率低，这里我们采用strcpy(),从指定位置开始拷贝，带\0

void string::append(const char* str)//插入字符串
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);//现在有_size个，我们需要插入长度为len的字符串
	}
	strcpy(_str + _size, str);
	_size += len;
}

同样测试通过，但效率很高

直接从\0位置开始插入

 

operator+=

说到尾插字符串，那必须得提到+=运算符重载，这里提供俩个版本

这里引用返回，返回对象本身，出了作用域对象还存在。

string& operator+=(char ch);//+=是需要返回值的，用引用返回减少拷贝
string& operator+=(const char ch);

这里我们直接调用push_bakc和append

string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}
string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

测试

inset() 和 erase()

size_t insert(size_t pos,char ch); //pos位插入字符
size_t insert(size_t pos,const char* ch);//插入字符串
void erase(size_t pos, size_t len = npos);//pos开始删除len个字符
private:
	//char _buff[16];  lunix下小于16字节就存buff里

	char* _str;

	size_t _size;
	size_t _capacity;

	const static size_t npos;

对于npos，静态成员如何初始化，在类里面声明，在类外定义。

类里的静态成员遍历，相当于全局变量，如果在string.h里定义，在预处理以后，string

.h会在string.cpp和test.cpp里展开，展开两份，俩文件最后生成.o文件，再一链接就出问题了，

声明和定义分离的时候把定义放在.cpp，声明放在.h。

insert()插入一个字符

size_t string::insert(size_t pos, char ch)
{
	if (_size == _capacity)//空间不够，就扩容
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}

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

测试

如果我们在0出插入一个字符呢？

显然报错了，为什么？

因为edn >= 0 继续交换，把0之前的哪个未知值也交换进去了，

当end >= pos = 0 时，已将交换完了，但又进入循环了，为什么？因为当操作符两边的操作数类型不同的时候，会发生隐式类型转化，当有符号遇到无符号，有符号转换为无符号，end变为非常大的数，end依据大于pos。那有什么方法来修改呢？

我们是否可以把pos改为int类型呢？答案是不建议，因为我们要与库里的类型一样。

直接把pos强制转为int,运行测试提供。

void string::insert(size_t pos, char ch)
{
	if (_size == _capacity)//空间不够，就扩容
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}

	size_t end = _size;
	while (end >= (int)pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}
	_str[pos] = ch;//把字符放进去
	++_size;
}

那么我们可以不强转可以修改吗？可以

这里最根本的问题点在于end >= pos,只要是无符号遇到>=绝对是坑，无符号最小就是0，无法停止，非常扯淡。

这里我们去掉= ，把end的位置变为_size + 1,把前一个往后挪。

代码修改为：

void string::insert(size_t pos, char ch)
{
	if (_size == _capacity)//空间不够，就扩容
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}

	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;//把字符放进去
	++_size;
}

测试通过

insert()插入一个字符串

void insert(size_t pos,const char* str);//插入字符串

首先pos不能越界，检查是否需要扩容，

把xxx拷贝进去，不能用strcpy，它携带了\0，我们可以用strncpy或memcpy，这里我们采用memcpy

代码：

void string::insert(size_t pos, const char* str)
{ 
	assert(pos <= _size);

	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	int end = _size;
	while (end >= pos)
	{
		_str[end + len] = _str[end];
		--end;
	}
	memcpy(_str + pos, str, len);
	_size += len;

}

测试通过

这是我们在0出插入，还是会遇到之前的问题

我们只需要把pos强制类型转化为int即可。

如果我们不想用这种方式，我们把=去掉，把前一个往后挪，

到pos + len依旧需要挪动，可以写成end>=pos+len

void string::insert(size_t pos, const char* str)
{ 
	assert(pos <= _size);

	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	/*int end = _size;
	while (end >=(int) pos)
	{
		_str[end + len] = _str[end];
		--end;
	}*/
	size_t end = _size + len;//len插入字符串长度
	while (end > pos + len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}

	memcpy(_str + pos, str, len);
	_size += len;

}

erase()

void erase(size_t pos, size_t len = npos);//pos开始删除len个字符

代码：第一种情况，删除的长度大于pos后的长度，直接全部删除；第二种情况，直接把不删除的字符覆盖在要删除的字符上。

void string::erase(size_t pos = 0, size_t len = npos)
{
	assert(pos < _size);

	if (len == npos || len >= _size - pos)//删除的字符大于pos后的字符
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len; 
	}

}

find()

查找一个字符

size_t string::find(char ch, size_t pos = 0)
{
	for (size_t i = 0; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}

查找一个子串


size_t string::find(const char* sub, size_t pos = 0)//从pos位置开始查找
{
	const char* p = strstr(_str + pos, sub);//在_str 种匹配sub子串，，返回对应位置指针
	return p - _str;//指针相减获取下标
}

测试通过

运算符重载 = 

看下面代码，s1赋值拷贝给s2，s3赋值给s1，下面程序有没有问题呢？

void test5()
{
	yx::string s1("hello world");
	yx::string s2(s1);
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;

	yx::string s3("yyyy");
	s1 = s3; // s3赋值给s1
	cout << s1.c_str() << endl;
	cout << s3.c_str() << endl;
}

当然是有问题的，当我们没有运算符重载=时，编译器会默认提供一个版本，会执行浅拷贝，当 s2 被创建为 s1 的副本时，s2 实际上可能仅仅是指向 s1 所指向的字符串常量的另一个指针。这意味着，如果改变 s2 所指向的内容，s1 的内容也会随之改变。所以需要我们实现深拷贝版本。

修正：

string& 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;
	}
}

重新开一个空间tmp，把需要拷贝的字符串拷贝进去，然后释放旧空间，把new的空间给给原空间

而且为了避免自己给自己赋值，需要再套一个判断 this ！= &s

优化写法：

s1 = s3，s是s3的别名

	string& string::operator=(const string& s)
	{
		if (this != &s)
		{
			string tmp(s._str);
			this->swap(tmp);
		}
		return *this;
	}

s3拷贝给s1，设置一个临时变量tmp，s3拷贝构造tmp，然后再交换s1和tmp的空间。

而且tmp是个局部对象，出了作用域会析构，免去了释放空间这一步

最简化的写法：

s1 = s3

string& operator=(string tmp);


string& string::operator=(string tmp)
{
	swap(tmp);
	return *this;
}

和上面最大的区别在于没有引用，s3拷贝构造tmp，然后s1和tmp交换，和上面的道理一样，tmp是临时对象，出了作用域自动销毁，效率并没有提示，只是简化了代码

swap()

如果我们swap一下s1 和 s2呢？库里的swap能否帮我们完成任务呢？答案是可以的，因为他是模板，但是它的代价非常大，

a 拷贝给 c，b 赋值给 a，c赋值给b，都会开空间，拷贝数据，传值传参代价都非常大。

自己实现：

void string::swap(string& s)
{
	std::swap(_str, s._str);//交换char*指针，size capacity
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

通过命名空间，来使用库里的swap，如果不写std，swap就会调用自己，而且这里面交换的都是内置类型

strsub()

从pos位置开始，取len个字符的子串

代码实现：

string string::substr(size_t pos, size_t len)
{
	if (len > _size - pos)//如果len大于pos后面的长度，有多少取多少
	{
		string sub(_str + pos);//_str（开始的指针 ） + pos 从pos位置开始取，然后构造一个子串返回
		return sub;
	}
	else
	{
		string sub;
		sub.reserve(len);//扩容
		for (size_t i = 0;i< len ;i++)
		{
			sub += _str[pos + i];
		}
		return sub;
	}
}

运算符重载 < > <= >= == !=

bool string::operator<(const string& s) const //比较大小
{
	return strcmp(_str, s._str) < 0;
}
bool string::operator>(const string& s) const
{
	return !(*this <= s);
}
bool string::operator<=(const string& s) const
{
	return *this < s || *this == s;
}
bool string::operator>=(const string& s) const
{
	return !(*this < s);
}
bool string::operator==(const string& s) const
{
	return strcmp(_str, s._str);
}
bool string::operator!=(const string& s) const
{
	!(*this == s);
}

其实这里写两个，然后取反复用就可以。

流插入和流提取operator<< >> 

istream& operator>>(istream& is, string& str)// is - cin
{
	char ch = is.get();
	is >> ch;
	while (ch != ' ' || ch != '\n')//不等于空格或换行
	{
		str += ch;//在io流里提取一个一个的char += 到str里
		char ch = is.get();
	}

	return is;
}
ostream& operator<<(ostream& os, const string& str)//os - cout
{
	for (size_t i = 0; i < str.size(); i++)
	{
		os << str[i];//一个一个插入
	}

	return os;
}

流插入和流提取的运算符重载不能写成成员函数，且不一定写成友元。

cin是不能获取空格的，而scanf可以 当输入 y 空格 y 时， 写两个cin ，两个cin都会获得y，而忽略空格。

clear()

void string::clear() //请调当前的数据
{
	_str[0] = '\0';
	_size = 0;
}

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

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

相关文章

文字炫酷祝福 含魔法代码

文字炫酷祝福 含魔法代码

效果下图&#xff1a;&#xff08;可自定义显示内容&#xff09; 代码如下&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initi…
阅读更多...
深度学习（十）——神经网络：非线性激活

深度学习（十）——神经网络：非线性激活

一、Padding Layers简介 nn.ZeroPad2d&#xff1a;在输入的tensor数据类型周围用0进行填充 nn.ConstantPad2d&#xff1a;在输入的tensor数据类型周围用常数进行填充 这个函数的主要作用是对输入的图像进行填充&#xff0c;但里面所有功能都能用nn.Conv2d实现。 二、Non-li…
阅读更多...
CAD二次开发（10）-单行文字的添加+图形修改

CAD二次开发（10）-单行文字的添加+图形修改

1. 单行文字的添加 第一步&#xff1a; 首先在CAD中新增中文样式 输入ST命令&#xff1a; 第二步&#xff1a;代码开发 /// <summary>/// 添加文本信息/// </summary>[CommandMethod("AddText")]public void AddText(){var doc Application.DocumentM…
阅读更多...
分析医药零售数据该用哪个BI数据可视化工具？

分析医药零售数据该用哪个BI数据可视化工具？

数据是企业决策的重要依据&#xff0c;可以用于现代企业大数据可视化分析的BI工具有很多&#xff0c;各有各擅长的领域。那么哪个BI数据可视化工具分析医药零售数据又好又快&#xff1f; 做医药零售数据分析首推奥威BI数据可视化工具&#xff01; 奥威BI数据可视化工具做医药…
阅读更多...
c++实现二叉搜索树（下）

c++实现二叉搜索树（下）

好久不见啊&#xff0c;baby们&#xff0c;小吉我又回归了&#xff0c;发完这一篇小吉将会有两周时间不会更新blog了&#xff08;sorry&#xff09;&#xff0c;在小吉没有发blog的日子里大家也要好好学习数据结构与算法哦&#xff0c;还有就是别忘了小吉我❤️  这篇博客是二…
阅读更多...
新火种AI|Sora发布半年之后，AI视频生成领域风云再起

新火种AI|Sora发布半年之后，AI视频生成领域风云再起

作者&#xff1a;一号 编辑&#xff1a;美美 AI视频最近有些疯狂&#xff0c;Sora可能要着急了。 自OpenAI的Sora发布以来&#xff0c;AI视频生成技术便成为了科技界的热门话题。尽管Sora以其卓越的性能赢得了广泛关注&#xff0c;但其迟迟未能面向公众开放&#xff0c;让人…
阅读更多...
计算机网络——传输层重要协议（TCP、UDP）

计算机网络——传输层重要协议（TCP、UDP）

一、常见名词解释 IP地址&#xff1a;IP地址主要用于标识网络主机、其他网络设备&#xff08;如路由器&#xff09;的网络地址&#xff0c;即IP地址用于定位主机的网络地址&#xff1b; IP地址是一个32位的二进制数&#xff0c;通常被分割为4个 8位⼆进制数&#xff08;也就是…
阅读更多...
C++之std::type_identity

C++之std::type_identity

目录 1.简介 2.C20的std::type_identity 3.使用 type_identity 3.1.阻止参数推导 3.1.1.模板参数推导过程中的隐式类型转换 3.1.2.强制显式实例化 3.2.阻止推断指引 3.3.类型保持 3.4.满足一些稀奇古怪的语法 4.示例 5.总结 1.简介 std::type_identity 是 C17 引入的…
阅读更多...
中考物理必考重点知识点总结

中考物理必考重点知识点总结

打印版&#xff0c;见文末
阅读更多...
运算放大器共模抑制比(CMRR)

运算放大器共模抑制比(CMRR)

目录 运算放大器共模抑制比(CMRR) 三运放共模抑制比电路 运算放大器共模抑制比(CMRR) 如果信号均等施加至运算放大器的两个输入端&#xff0c;使差分输入电压不受影响&#xff0c;则输出也不应受影响。实际上&#xff0c;共模电压的变化会引起输出变化。运算放大器共模抑制比…
阅读更多...
鸿蒙实现金刚区效果

鸿蒙实现金刚区效果

前言&#xff1a; DevEco Studio版本&#xff1a;4.0.0.600 所谓“金刚区"是位于APP功能入口的导航区域&#xff0c;通常以“图标文字”的宫格导航的形式出现。之所以叫“金刚区”&#xff0c;是因为该区域会随着业务目标的改变&#xff0c;展示不同的功能图标&#xff…
阅读更多...
SpringMVC—RequestMapping注解

SpringMVC—RequestMapping注解

一、RequestMapping注解 RequestMapping注解&#xff1a;是Spring MVC框架中的一个控制器映射注解&#xff0c;用于将请求映射到相应的处理方法上&#xff0c;具体来说&#xff0c;他可以将指定URL的请求绑定到一个特定的方法或类上&#xff0c;从而实现对请求的处理和响应。 …
阅读更多...
充电学习—7、BC1.2 PD协议

充电学习—7、BC1.2 PD协议

BC1.2&#xff08;battery charging&#xff09;充电端口识别机制&#xff1a; SDP、CDP、DCP 1、VBUS detect&#xff1a;vbus检测 PD&#xff08;portable device&#xff0c;便携式设备&#xff09;中有个检测VBUS是否有效的电路&#xff0c;电路有个参考值&#xff0c;高…
阅读更多...
高级算法复习指南

高级算法复习指南

自用 如果帮到了你就点个关注和赞吧&#xff01; 1.算法知识回顾 求两个不全为0的非负整数m和n的最大公约数 数据结构回顾 数组 连续内存分配、静态大小、类型一致、索引访问、访问时间相同、边界检查 多维数组&#xff1a;数组的数组&#xff0c;可以是连续的&#xff0c…
阅读更多...
不重新安装Anaconda找回不见的Anaconda Prompt

不重新安装Anaconda找回不见的Anaconda Prompt

找回Anaconda Prompt只需三步 系统&#xff1a;win11 x641.cd Anaconda的安装目录2. Anaconda Prompt又回来了 系统&#xff1a;win11 x64 1.cd Anaconda的安装目录 winR 输入cmd 进入命令行&#xff0c;进入到Anaconda的安装目录 eg&#xff1a;我的Anaconda安装在&#xff…
阅读更多...
Ptrade和QMT的区别，怎么获取合适的量化交易软件？

Ptrade和QMT的区别，怎么获取合适的量化交易软件？

​Ptrade和QMT的适用人群 交易活跃用户 量化爱好者已经专业量化投资者 高净值个人或机构 Ptrade和QMT的区别 回测和交易频率 Ptrade回测和交易只支持分钟级和日线级别的频率&#xff0c;而QMT支持tick级、分钟级、5分钟级、10分钟级、日线、周线、月线等。 使用QMT进行回…
阅读更多...
GDB调试相关教程

GDB调试相关教程

GDB调试相关教程 相关参考链接 https://wizardforcel.gitbooks.io/100-gdb-tips/content/set-step-mode-on.htmlhttps://wizardforcel.gitbooks.io/100-gdb-tips/content/set-step-mode-on.html 设置程序运行参数 命令set args 10 20 30 40 使用show args显示设置好的运行参…
阅读更多...
线性稳压器LDO的基础知识

线性稳压器LDO的基础知识

一、什么是线性稳压器? 线性稳压器的工作原理是&#xff1a;采用一个压控电流源以强制在稳压器输出端上产生一个固定电压。控制电路连续监视&#xff08;检测&#xff09;输出电压&#xff0c;并调节电流源&#xff08;根据负载的需求&#xff09;以把输出电压保持在期望的数值…
阅读更多...
(微服务实战)聚合支付系统商户线上聚合收银台接口设计

(微服务实战)聚合支付系统商户线上聚合收银台接口设计

1 概述 聚合支付收款分为线上和线下业务场景&#xff0c;本文中的商户收银台接口设计主要是指线上业务场景&#xff0c;线下业务场景聚合收款方式后续会进行单独设计和分析。 主流的线上支付渠道有微信支付&#xff0c;支付宝支付&#xff0c;云闪付。这三种支付渠道都有各自…
阅读更多...
JupyterLab使用指南(五):JupyterLab的 扩展

JupyterLab使用指南(五):JupyterLab的 扩展

1. 什么是JupyterLab的扩展 JupyterLab 扩展&#xff08;Extension&#xff09;是一种插件机制&#xff0c;用于增强 JupyterLab 的功能。通过安装扩展&#xff0c;用户可以添加新的功能、改进现有功能&#xff0c;甚至自定义界面和工作流。扩展可以覆盖各种用途&#xff0c;从…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023