string(三)

于 2024-09-09 23:08:13 发布
阅读量450 收藏 7
点赞数 11
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yunbao00_/article/details/141904893
版权

可以看到中文的在数组中是无法正常在监视窗口中显示的

字符是通过ascll码存储的 那么中文和其他地区的文字又是通过什么存储的？

是通过unicode 也就是万国码 可能是由多个字节来确定一个汉字

接下来介绍一下string模版


    	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;//静态成员变量不走初始化列表 不能将缺省值放在这里 但是加上const之后就行了 且只能适用于整型

这是string模版的私有成员   其中npos是静态成员变量 

string(const char* str = "");//写成全缺省 这里不用给构造后会自动给斜杠零
	string::string(const char* str)
		//sizeof是编译时 strlen是运行时去计算长度 
		:_size(strlen(str)) //注意初始化列表的初始化顺序  初始化列表初始化容易出现问题 所以决定使用初始化列表加函数体进行初始化	
	{
		_str = new char[_size+1];//写成方括号不写圆括号是为了和delete对齐
		_capacity = _size;
		strcpy(_str,str);
	}

这里是string的构造  这里的初始化列表与代码块一起使用来进行初始化  初始化列表的初始化顺序是按照私有成员的创建顺序进行的 和这里的顺序无关

这里写成全缺省 就不用在写一个构造空string对象的函数了 同时缺省值不需要其他写上双引号会自动添加斜杠零

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

这里()括号后的const修饰的成员变量 保证成员变量在函数中不会发生改变

void string1()
{
	bit::string s1("hello world");
	cout << s1.string::c_str() << endl;
	
	
}
		size_t size() const;
	size_t string:: size() const
	{
		return _size;
	}

size函数也是使用const修饰函数成员 防止在函数体中发生改变

接下来要介绍遍历 这里需要[]和迭代器进行访问

这里的iterator 利用的是char*指针 begin和end分别返回字符串数组首元素和有效元素最后一位的下一位 []的参数是下标 返回的值的对应数组下标位置中的内容 []不仅可以访问内容也可以进行修改

typedef char* iterator;
iterator begin();
iterator end();		
string::iterator string::begin()
{
	return _str;
}

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

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

遍历的方式有三种 [] 迭代器 范围for

void string1()
{
	bit::string s1("hello world");
	cout << s1.string::c_str() << endl;
	for (size_t i = 0; i < s1.size(); i++)
	{
		s1[i]++;
	}
	for (size_t i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << " ";
	}
	cout << endl;
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;
	bit::string::iterator it1 = s1.begin();//写成char*也能通过 为什么还要typedef成iterator呢  这其实是第二次封装 通过typedef封装迭代器iterator
	while (it1 != s1.end())//封装：屏蔽了底层实现细节 提供了一种简单通用的访问容器的方式
	{
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;
	bit::string s2;
	cout << s2.string::c_str() << endl;
}

接下来介绍push_back和append push_back是尾插一个字符 而append则可以尾插字符串


 void push_back(char ch);

void string:: push_back(char ch)
{
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}

	_str[_size++] = ch;
	_str[_size] = '\0';
	
}
 void append(const char*str);
void string:: append(const char* str)
{
	
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(len + _size);
	}
	//strcat(_str, str);//strcat会从\0位置开始 进行拼接 并且会和strcpy一样将\0放到末尾
	strcpy(_str+_size, str);//strcpy更合适 直接自己设置拼接位置
	_size += len;
	
}

这里无论push_back还是append都要检查空间是否足够 若是不够则需要扩容

扩容则需要用到reserve reserve可以用作扩容修改_capacity

	  void reserve(size_t n);
	void string :: reserve(size_t n)
	{
		if (n > _size)
		{
			char* tmp = new char[n+1];
			strcpy(tmp,_str);
			delete[] _str;

			_str = tmp;
			_capacity = n;
		}
	}

reserve进行的是深拷贝 即创立一个更大的空间 再将原本空间的内容拷贝到新空间 将旧空间释放 之后在将_str指正指向新空间 将_capacity更新后完成扩容

void string3()
{
	bit::string s5("hello world");
	cout << s5.c_str() << endl;
	s5.push_back('x');
	cout << s5.c_str() << endl;
	s5.append("66666666");
	cout << s5.c_str() << endl;

	s5 += 'z';
	cout << s5.c_str() << endl;
	s5 += "99999";
	cout << s5.c_str() << endl;
}

接下来介绍insert函数 insert可以在有效字符串的内容中任意位置插入字符或者字符串

由于插入内容的不同 所以写了两个insert函数

  void insert(size_t pos,char ch);
void string::insert(size_t pos, char ch)
{
	assert(pos <=_size);
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	//int end = _size;
	//while (end >= (int)pos)//这里涉及一个问题 在一个运算符或者操作符的两边 如果类型不一样 会自动隐式类型转换有符号会转换成无符号
	//{//解决方法一 将操作数强转换成整型 
	//	_str[end + 1] = _str[end];
	//	--end;
	//}

	size_t end = _size+1;
	while (end > pos)//这里涉及一个问题 在一个运算符或者操作符的两边 如果类型不一样 会自动隐式类型转换有符号会转换成无符号
	{//解决方法二 改变挪动方法
		_str[end ] = _str[end-1];
		--end;
	}
	_str[pos] = ch;
	_size++;
}

这由于需要插入数据 可能空间不够所以需要扩容 

而插入位置是任意的 所以可能需要挪动字符 为插入的内容腾出空间 而挪动字符位置的方式有两种 

一种是end = _size+1 一种是end = _size  两种都可以挪动字符

	  void insert(size_t pos,const char*str);
void string:: insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(len + _size);
	}
	/*int end = _size;
	while (end >=(int)pos)
	{
		_str[end + len] = _str[end];
		--end;
	}*/
	size_t end = _size + len;
	while (end >= pos+len)
	{
		_str[end] = _str[end - len];
		--end;
	}
	memcpy(_str+pos,str,len);
	_size += len;

}

这里插入内容也是要判断是否需要扩容的 

同时也需要挪动字符串

这里可能会遇到一个问题 

while (end > pos)//这里涉及一个问题 在一个运算符或者操作符的两边 如果类型不一样 会自动隐式类型转换有符号会转换成无 这样在头插时就会导致循环无法停止 需要强转 或者保证类型一直

在写完insert之后 在实现append和push_back就可以直接使用insert函数进行复用

void string:: push_back(char ch)
{
	/*if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}

	_str[_size++] = ch;
	_str[_size] = '\0';*/
	insert(_size,ch);
}
void string:: append(const char* str)
{
	
	//size_t len = strlen(str);
	//if (_size + len > _capacity)
	//{
	//	reserve(len + _size);
	//}
	strcat(_str, str);//strcat会从\0位置开始 进行拼接 并且会和strcpy一样将\0放到末尾
	//strcpy(_str+_size, str);//strcpy更合适 直接自己设置拼接位置
	//_size += len;
	insert(_size,str);
}
void string4()
{
	bit::string s1("hello world");
	cout << s1.c_str() << endl;
	/*s1.insert(6,'x');
	cout << s1.c_str() << endl;*/
	s1.insert(0,'x');
	cout << s1.c_str() << endl;
	s1.insert(0,"11111");
	cout << s1.c_str() << endl;
}

在插入内容之后就介绍erase来删除数据

	  void erase(size_t pos = 0 ,size_t len = npos);
	void string:: erase(size_t pos, size_t len )
	{
		assert(pos < _size);
		if ( pos +len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + len + pos);
			_size -= len;
		}
		
	}

这里通过assert来判断下标是否合法

对于长度 如果从pos开始 len大于剩余有效字符长度 那么就全部删除 也就是在pos位置修改为斜杠零 同时将_size修改为pos

反之 就通过strcpy对字符串进行重新拼接 之后更新_size

void string5()
{
	bit::string s1("hello world");
	cout << s1.c_str() << endl;
	s1.erase(6,3);
	cout << s1.c_str() << endl;
}

接下来介绍find 如果能够找到就返回对应的下标

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

 size_t find(const char* sub, size_t pos = 0);
size_t string:: find(const char* sub, size_t pos )
{
	//字符串匹配 这里使用strstr
	const char* p = strstr(_str+pos,sub);//strstr返会指针 用返会位置的指针减去开始位置的指针就等于这个位置的下标
	return p - _str;
}


void string6()
{
	bit::string s1("hello world");
	cout << s1.find('o') << endl;
	cout << s1.find("wor") << endl;
}

这是一个浅拷贝问题  解决方法是要设置为深拷贝

void string7()
{
	bit::string s1("hello world");
	bit::string s2(s1);//这里涉及到浅拷贝问题 两个对象公用一片空间  这时存在两个问题 1.会析构两次 2.一个修改 另一个也会改变
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
}
	  string(const string& s);
	string ::string(const string& s)//现代写法（让别人干活交换）
	{
		string tmp(s._str);
		swap(tmp);//这里相当于复用了之前写过的一个成员变量的swap
	}
string ::string(const string& s)//传统写法
{
	_str = new char[s._capacity+1];
	strcpy(_str,s._str);
	_size = s._size;
	_capacity = s._capacity;
}

如果使用库中的swap直接对string进行交换 那么效率会特别低 所以需要写一个string自己的成员函数swap  

这里的swap一次交换 一次深拷贝 两次赋值 一共三次深拷贝代价很大

   	  void swap(string&s);
	void string::swap(string& s)
	{
		//简单方法就是不要直接交换string 而是选择交换指针  
		std::swap(_str,s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
		//swap一共有三个 std中的 成员函数的 和全局的 其中全局和成员函数是损耗较低的
	}

这里不是用库中的swap直接交换而是通过对string中私有函数成员的进行交换  可以减少损耗

我们的=重载也是使用swap进行函数复用的


	string& string::operator=(const string& s)
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;
	}

	return *this;
}
void string8()
{
	bit::string s1("yyyyy");
	bit::string s2("hello world");

	s1 = s2;
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
}

substr 可以用与分割字符串 返回的字符串可以用于赋值string类对象

	  string substr(size_t pos = 0,size_t len = npos);
	string string:: substr(size_t pos, size_t len )//在声明的时候写好默认参数 在定义时就不需要写了 （在声明和定义分离的情况下）
	{
		if (len > _size-pos )
		{
			string sub(_str+pos);
			return sub;

		}
		else
		{
			string sub;
			sub.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				sub += _str[pos + i];
			}
			return sub;
		}
		
	}

这里是通过创建一个新对象 同时通过拷贝构造将内容进入新对象 之后返回

void string9()
{
		bit::string url("https://gitee.com/ailiangshilove/cpp-class/blob/master/%E8%AF%BE%E4%BB%B6%E4%BB%A3%E7%A0%81/C++%E8%AF%BE%E4%BB%B6V6/string%E7%9A%84%E6%8E%A5%E5%8F%A3%E6%B5%8B%E8%AF%95%E5%8F%8A%E4%BD%BF%E7%94%A8/TestString.cpp");
		size_t pos1 = url.find(':');
		bit::string url1 = url.substr(0, pos1 - 0);
		cout << url1.c_str() << endl;

		size_t pos2 = url.find('/', pos1 + 3);
		bit::string url2 = url.substr(pos1 + 3, pos2 - (pos1 + 3));
		cout << url2.c_str() << endl;

		bit::string url3 = url.substr(pos2 + 1);
		cout << url3.c_str() << endl;
	
}

通过这个函数可以将网址的区域分开

重载流插入和流提取   流插入是通过遍历的方式进行将其打印 

 

流插入由于每次有肯能会进行扩容 会造成大损耗 所以设置了buff字符数组 这里只有当buff数组满了才会+=赋值一次扩容一次 这样可以大大减少损耗  这里使用get()可以防止在提取空格和斜杠零时防止提取不到 这样循环就会一直持续

istream& operator>>(istream &is,string& str);
istream& operator>>(istream& is, string& str)
{
	str.clear();

	char buff[128];
	char ch = is.get();
	int i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}
		ch = is.get();
	}
	if (i != 0)
	{
		buff[i] = '\0';
		str += buff;
	}
	return is;
}
ostream& operator << (ostream &os,const string& str);
ostream& operator << (ostream& os, const string& str)
{
	for (size_t i = 0;i<str.size();i++)
	{
		os << str[i];
	}
	return os;
} 

void string10()
{
	bit::string s1("hello world");
	cout << s1 << endl;
	cin >> s1;
	cout << s1 << endl;
}

yunbao00_
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值