秒懂C++之string类（下）

玛丽亚后

已于 2024-07-27 02:57:19 修改

阅读量1.6k

点赞数 63

分类专栏： c++ 文章标签： c++ 算法开发语言

于 2024-07-27 02:47:52 首次发布

本文链接：https://blog.csdn.net/fax_player/article/details/140676425

版权

c++ 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

一.接口说明

1.1 erase

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string s1("hello world");
	s1.erase(0, 4);
	cout << s1 << endl;//o world 从下标为0开始，删除4个字符
	s1.erase();
	cout << s1 << endl;//

	return 0;

}

1.2 replace（最好别用）

int main()
{
    string s1("hello world");
	string s2;
	s1.replace(0, 1, "aaaa");
	cout << s1 << endl;//aaaaello world

	return 0;
}

替换指定位置内容，并挪动后面数据。

1.3 find

int main()
{
    string s1("hello world a b");
	// 所有的空格替换为100%
	size_t pos = s1.find(' ', 0);//从下标为0位置开始找
	while (pos != string::npos)
	{
		s1.replace(pos, 1, "100%");
		// 效率很低，能不用就不要用了

		pos = s1.find(' ', pos + 4);
	}
	cout << s1 << endl;//hello100%world100%a100%b

	return 0;
}

作用就是从头开始找到该字符并返回其下标位置。

之所以不用replace是因为有更好的替代~
int main()
{
	string s1("hello world a b");
	string s2;
	for (auto ch : s1)
	{
		if (ch == ' ')
		{
			s2 += "100%";
		}
		else
		{
			s2 += ch;
		}
	}
	s1.swap(s2);
	cout << s1 << endl;//hello100%world100%a100%b

	return 0;
}
注意：

swap(s1,s2)与s1.swap(s2)可不一样，前者是通过有个中间变量进行交换，而后者是让双方指针进行交换，后者更为高效~

1.4 substr

int main()
{
	string s1("hello");
	string s2;
	s2 = s1.substr(1, 2);
	cout << s2 << endl;//el
	cout << s1.substr(1) << endl;//ello

	return 0;
}
在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

1.5 rfind

从末尾开始找字符并返回下标

int main()
{
	//获取后缀名
	string s1("Test.cpp");
	string s2("Test.tar.zar");

	size_t pos1 = s1.find('.');
	size_t pos2 = s2.rfind('.');

	if(pos1 != string::npos)
	{
		string s3 = s1.substr(pos1);
		cout << s3 << endl;//.cpp

		string s4 = s2.substr(pos2);
		cout << s4 << endl;//.zar

	}

	return 0;
}

1.6 find_first_of

int main()
{
	string s1("hello world");

	size_t pos1 = s1.find_first_of("abcde");
	cout << pos1 << endl;//1

	pos1 = s1.find_first_of("ow");
	cout << pos1 << endl;//4


	return 0;
}
返回在选定字符串中任意一个字符第一次出现的下标。（从头开始遍历）

1.7 find_last_of

int main()
{
	string s1("hello world");

	size_t pos1 = s1.find_last_of("abcde");
	cout << pos1 << endl;//10

	pos1 = s1.find_last_of("h");
	cout << pos1 << endl;//0


	return 0;
}
返回在选定字符串中任意一个字符第一次出现的下标。（从尾开始遍历）

注意：find_first_not_of与find_last_not_of，就是返回指选定字符串之外的字符下标
int main()
{
	string s1("hello world");

	size_t pos1 = s1.find_first_not_of("abcde");
	cout << pos1 << endl;//0

	pos1 = s1.find_last_not_of("h");
	cout << pos1 << endl;//10


	return 0;
}

二.string类的模拟实现

2.1 构造

首先实现构造函数的时候在初始化列表不能直接这么写，涉及到了权限放大~

也不能在私有成员那写：const char* _str，这样_str以后只能指向一处，无法修改指向，也意味着无法增删改。
namespace lj
{
	class string
	{
	public:
		//构造
		string(const char* str)
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];//加1是因为在_capacity那被认为‘\0’是有效字符
            strcpy(_str, str);

		}
	private:
		size_t _size;
		size_t _capacity;
		char* _str;
	};
	void test_string1()
	{
		string s1("aabbcc");//构造成功
	}
}
建议直接放弃在列表初始化，还得考虑声明顺序啥的挺麻烦~

2.2 无参构造

		//无参构造
		string()
		{
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		//返回c格式字符串
		const char* c_str()
		{
			return _str;
		}
可惜这种无参写法不行，因为c_str是以指针的形式返回的(字符串形式），而cout接触到指针会认为是要打印字符串，直接解引用指针，一个空指针被解引用是错误的。

开辟个1字节的空间，里面放个字符（但不是有效字符）

不过与其写无参不如直接写缺省参数

//为什么字符串就能匹配上啊？,因为这样指针就能指向它，本身是地址。

2.3 析构

~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}

2.4.【】运算符

		char& operator[](size_t pos)
		{
			return _str[pos];
		}

//为什么里面还能有【】，因为这个是给内置类型使用的，自定义类型要自己自定义

2.5 迭代器

typedef char* iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}
其实迭代器实现也挺简单的~

for+auto的遍历底层逻辑其实还是迭代器。

2.6 打印

首先调用size()函数的时候出现了权限放大的问题，调用运算符【】也是如此。所以在这里我们就要引入const成员函数进行修改~对需要改变自身的额外再写一个针对const权限函数，对不需要改变自身的加入const。
void print_str(const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			//s[i]++;
			cout << s[i] << endl;
		}

		string::const_iterator it = s.begin();
		while (it != s.end())
		{
			// *it = 'x';

			cout << *it << " ";
			++it;
		}
		cout << endl;

	}

2.7 reserve扩容

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];//还有一个开给\0
				strcpy(tmp, _str);//拷贝所指向的内容
				delete[] _str;//销毁旧空间
				_str = tmp;//指向新空间
				_capacity = n;
			}
		}

2.8 push_back尾插

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

			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}
由于\0不算有效字符，所以最后计算完后_size都会与其下标相等，而这时候可以刚好插入字符。最后需要注意人工补上\0。

2.9 append追加

		void append(const char* str)
		{
			size_t len = strlen(str);//计算所追加的长度
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str+_size, str);
			_size += len;

		}
//strcpy(_str+_size, str);为什么不是_size就行了呢？因为_size是一个数据不是一个指针，而_str是指针+数可以达到偏移的效果