C/C++ string模拟实现

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

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

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

相关文章

技术与创意并驾齐驱：打造扭蛋机小程序的独特魅力

技术与创意并驾齐驱：打造扭蛋机小程序的独特魅力

引言 扭蛋机小程序以其独特的玩法和吸引力&#xff0c;在移动互联网市场中崭露头角。本文将深入探讨如何通过技术与创意的并驾齐驱&#xff0c;打造扭蛋机小程序的独特魅力。 一、技术驱动&#xff1a;打造稳定高效的小程序平台 在扭蛋机小程序的开发过程中&#xff0c;技术是…
阅读更多...
14K屏FPGA通过MIPI接口点亮

14K屏FPGA通过MIPI接口点亮

一、屏参数 屏分辨率为13320*5120&#xff0c;MIPI接口8 LANE。 二、驱动接口电路 屏偏置电压5.5V&#xff0c;逻辑供电1.8V。8 LANE MIPI&#xff0c;2 PORT。 三、MIPI DSI规范 DCS (Display Command Set)&#xff1a;DCS是一个标准化的命令集&#xff0c;用于命令模式的显…
阅读更多...
研导智能科技（日照） 主要业务范围介绍

研导智能科技（日照） 主要业务范围介绍

研导智能科技的核心业务包括以下几个方面&#xff1a; 1. AI辅助科研产品开发&#xff1a; 公司专注于开发基于人工智能的科研辅助产品&#xff0c;开发的研导学术平台&#xff08;www.zhiyanxueshu.com)可以帮助科研人员在科研写作、数据分析、文献检索、课题申报、前沿热点识…
阅读更多...
2024请收好这一份全面--详细的AI产品经理从业指南

2024请收好这一份全面--详细的AI产品经理从业指南

前言 入行人工智能领域这段时间以来&#xff0c;从零到一把AI推荐系统产品化搭建了起来&#xff0c;也与很多同行AI产品经理小伙伴建立了联系。AI产品经理工作内容各异&#xff0c;不同AI产品化生命周期中更是大为不同&#xff0c;但对想入行AI产品经理的小伙伴来讲&#xff0…
阅读更多...
最新AI智能聊天对话问答系统源码（详细图文搭建部署教程）+AI绘画系统（Midjourney），DALL-E3文生图，TTS语音识别输入，文档分析

最新AI智能聊天对话问答系统源码（详细图文搭建部署教程）+AI绘画系统（Midjourney），DALL-E3文生图，TTS语音识别输入，文档分析

一、文章前言 随着人工智能技术的持续进步&#xff0c;AI绘画已经发展成为一个日益成熟的领域。越来越多的人开始尝试使用AI绘画软件来创作艺术作品。尽管这些AI绘画软件对绘画领域产生了显著影响&#xff0c;但它们并不会完全取代画师。与传统手绘不同&#xff0c;AI绘画可以…
阅读更多...
CityEngine记录1：工程目录

CityEngine记录1：工程目录

CityEngine的工程目录结构对于理解和组织3D城市建模项目至关重要。以下是对CityEngine工程目录结构的详细解析&#xff1a; Assets&#xff1a; 存放模型的零件与纹理图片。这些资产通常用于在建模过程中为建筑物、道路、植被等元素添加详细的纹理和细节。 Data&#xff1a; …
阅读更多...
今日分享丨点亮这四个技能，你也可以成为可视化专家

今日分享丨点亮这四个技能，你也可以成为可视化专家

引言 以大数据、人工智能等为代表的新质生产力时代已悄然而至&#xff0c;央企、国企逐步意识到数据资源展示对于经营管理的重要性和紧迫性。数据可视化成为连接用户与数据的桥梁&#xff0c;藉由设计师的巧手&#xff0c;把复杂抽象的数据以基于管理需求&#xff0c;转化为直…
阅读更多...
tkinter实现一个GUI界面-快速入手

tkinter实现一个GUI界面-快速入手

目录 一个简单界面输出效果其他功能插入进度条文本框内容输入和删除标签内容显示和删除 一个简单界面 含插入文本、文本框、按钮、按钮调用函数 # -*- coding: UTF-8 -*-import tkinter as tk from tkinter import END from tkinter import filedialog from tkinter impor…
阅读更多...
PAT B1018.锤子剪刀布

PAT B1018.锤子剪刀布

题目描述 大家应该都会玩“锤子剪刀布”的游戏:两人同时给出手势,胜负规则如图3-1所示。 现给出两人的交锋记录&#xff0c;请统计双方的胜、平、负次数&#xff0c;并给出双方分别出什么手势的胜算最大。输入格式 第一行给出正整数N(≤10),即双方交锋的次数。随后N行,每行给…
阅读更多...
ESP-Mesh-Lite自组网方案，乐鑫ESP32无线联网应用，启明云端乐鑫代理商

ESP-Mesh-Lite自组网方案，乐鑫ESP32无线联网应用，启明云端乐鑫代理商

随着物联网技术的飞速发展&#xff0c;智能交互生活逐渐成为现代生活的一部分。乐鑫以其ESP-Mesh-Lite网络技术&#xff0c;为智能设备领域带来了革命性的变革。 ESP-Mesh是基于Wi-Fi协议自主研发的无线Mesh组网方案&#xff0c;通过ESP32系列SoC的高性能处理能力和丰富的通信…
阅读更多...
http缓存及http2配置

http缓存及http2配置

http缓存及http2配置极大提高了网页加载得速度 1.1 nginx安装 首先是需要安装nginx 去官网下载windows版本的安装包 nginx 命令 nginx start //启动 nginx -s stop nginx -s reload // 重新运行 tasklist /fi "imagename eq nginx.exe" //进程 把打包好的文件copy…
阅读更多...
Python4 操作MySQL数据库

Python4 操作MySQL数据库

通过python的pymysql库连接到本地的MySQL数据库&#xff0c;并执行查询操作来获取数据&#xff0c;然后打印出每一行的数据&#xff0c;这里以一个简单的学生表为例进行介绍。 1. MySQL的安装与数据准备 首先需要安装MySQL&#xff0c;在安装完成之后使用Navicat与本地数据库…
阅读更多...
数据分析：RT-qPCR分析及R语言绘图

数据分析：RT-qPCR分析及R语言绘图

介绍 转录组分析是一种用于研究细胞或组织中所有RNA分子的表达水平的高通量技术。完成转录组分析后&#xff0c;科学家们通常需要通过定量实时聚合酶链式反应&#xff08;qRT-PCR&#xff09;来验证二代测序&#xff08;Next-Generation Sequencing, NGS&#xff09;结果的可靠…
阅读更多...
就业市场挑战重重，求职者如何进入Salesforce生态系统?

就业市场挑战重重，求职者如何进入Salesforce生态系统?

目前&#xff0c;就业市场充满挑战&#xff0c;轻松进入Salesforce生态系统的日子已经一去不复返了。尽管入门级角色仍然存在&#xff0c;但市场上的申请者数量已超过其需求。成千上万的求职者争夺有限的职位&#xff0c;因此从人群中脱颖而出需要制定战略方法&#xff0c;求职…
阅读更多...
3d模型有个虚拟外框怎么去除？---模大狮模型网

3d模型有个虚拟外框怎么去除？---模大狮模型网

在3D建模和渲染过程中&#xff0c;虚拟外框(Bounding Box)是一个常见的显示元素&#xff0c;用于表示模型的包围盒或选择状态。尽管虚拟外框在一些情况下有其作用&#xff0c;但在最终渲染或呈现阶段&#xff0c;我们通常希望清除这些辅助显示&#xff0c;以展示纯粹的模型效果…
阅读更多...
JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

JAVAEE之网络原理（2）_传输控制协议(TCP)的连接管理机制，三次握手、四次挥手，及常见面试题

前言 在上一节中&#xff0c;我们简单介绍了 TCP 协议的相关概念和格式&#xff0c;而且还介绍了TCP 协议原理中的 确认应答机制、超时重传机制&#xff0c;在本节中我们将会继续介绍 TCP协议原理中的其他机制。 连接管理机制&#xff08;安全机制&#xff09; 在正常情况下&…
阅读更多...
搭建musetalk数字人的步骤

搭建musetalk数字人的步骤

生成数字人的视频效果 搭建步骤 下载git代码 git clone https://github.com/TMElyralab/MuseTalk.git创建conda环境 (建议使用 python 版本 >3.10 和 cuda 版本 11.7。) conda create -n musetalk python3.10进入conda环境 conda activate musetalk下载项目依赖包 pip…
阅读更多...
安装免费版的jfrog artifactory oss

安装免费版的jfrog artifactory oss

1、下载 软件&#xff0c;本案例安装的是 jfrog-artifactory-oss-7.59.11-linux.tar.gz https://releases.jfrog.io/artifactory/bintray-artifactory/org/artifactory/oss/jfrog-artifactory-oss/ 2、解压下载下来的压缩包 tar zxf jfrog-artifactory-oss-7.59.11-linux.tar…
阅读更多...
晨持绪科技：抖音小店的前景究竟怎么样

晨持绪科技：抖音小店的前景究竟怎么样

随着移动互联网的迅猛发展&#xff0c;短视频平台快速崛起并逐渐成为人们日常生活中不可或缺的一部分。作为国内领先的短视频平台&#xff0c;抖音在近年推出了“抖音小店”功能&#xff0c;为商家提供了一个新兴的、流量巨大的电商渠道。这一功能的推出不仅改变了传统的购物方…
阅读更多...
Sui主网升级至V1.27.2版本

Sui主网升级至V1.27.2版本

其他升级要点如下所示&#xff1a; 重点&#xff1a; #17245 增加了一个新的协议版本&#xff0c;并在开发网络上启用了Move枚举。 JSON-RPC #17245: 在返回的JSON-RPC结果中增加了对Move枚举值的支持。 GraphQL #17245: 增加了对Move枚举值和类型的支持。 CLI #179…
阅读更多...
最新文章

Copyright @ 2022~2023