C++学习指南(四)------string

最新推荐文章于 2024-10-20 20:14:58 发布

xqhoj

最新推荐文章于 2024-10-20 20:14:58 发布

阅读量850

点赞数 16

分类专栏： C++学习指南文章标签： c++ 开发语言算法学习 c语言

本文链接：https://blog.csdn.net/xqhoj/article/details/141138647

版权

C++学习指南专栏收录该内容

6 篇文章 0 订阅

订阅专栏

欢迎来到繁星的CSDN。本期内容主要包括字符串string。

一、什么是string？

C语言中的string

我们在C语言中已经遇到过字符串了。

那为什么C++还要单独的列出来string呢？

尽管这里包的头文件是iostream，但arr数组储存常量字符串123456789的形式仍然是C语言中的，即将字符串中的每个字符储存在一个对应数组元素中，以便可以一个个访问。

但是麻烦的是，在书写某些代码的时候，我们需要注意\0是否被覆盖。

不然“烫烫烫烫”警告。

除此以外，大部分的功能还需要我们自己实现，这大大下降了我们开发的效率。所以我们对string，特别封装了一个类，而这也是打开STL库的序章（尽管string不在这其中）

二、string的功能/函数

string功能多多，基本将开发的所有情况都统概了一遍，但是由于封装时间较早，所以在说明文档里的函数和功能较多。

而且存在重复的情况（如length和size功能完全相同，+=和append功能完全相同等等）

所以在此罗列一些函数说明，而要想看所有功能也可以到以下链接查看。

cplusplus.com/reference/

(只需要在左侧点到string部分即可查看）

特别注释：

以下演示的函数参数，仅仅是为了表示参数类型和功能，实际应用时还请查看文档。

2.1string的构造函数

作为一个类，自然少不了构造，而主要的构造方式有以下几种。

string(); //构造一个空string。

string(const char*s); //根据C语言格式的字符串构造一个string。

string(size_t n,char c); //在该string中构造n个字符，字符为给出的c。

string(const string&s); //拷贝构造函数。

2.2string的容量操作

我们时常关心某一字符串的长度，并且有了strlen函数。

在顺序表中，我们还特地写了一个size，一个capacity。

但现在对于字符串而言，我们有了更简便的方式。

size();                  //返回字符串有效字符长度

capacity();                   //返回空间总大小

empty();                  //检测字符串是否为空

clear();                  //清空字符串

reserve(size_t n); //为字符串预留空间

resize(size_t n,char c); //将有效字符的个数改为n个，多出的空间用字符填充

注：

size和length的底层一致，功能相同，并且按照vector等其他容器的惯常用法，只需记size

clear函数只会清空字符串，而不改变capacity，即开辟空间的大小。

reserve函数在不同编译器中表现不同，不同点在于如果n开的过大，VS2022不会进行缩容操作，但g++（即linux）环境下会进行缩容操作。而在说明文档中，我们注意到non-binding一词，所以这两种操作都是被允许的。使用不同编译器的时候，需要注意。

2.3string的访问

对于开辟的字符串，我们自然也需要方便的访问方式。

与C语言中一样，我们特地重载了[ ] ，作为访问string的方式。

operator[ ] //返回pos位置的字符，const string类对象调用。

begin() //begin获取一个字符的迭代器，可以暂时理解为类似于数组首元素指针。

但实际上并不相同。

end() //end获取最后一个字符下一个位置的迭代器。

rbegin() //rbegin获取一个字符的反向迭代器，即从字符串的末尾开始。

rend() //rend获取最后一个字符下一个位置的反向迭代器。

其中，begin与end代表了正向迭代器，rbegin与rend代表了反向迭代器。

这两对迭代器为我们提供了正向与反向的遍历方式，但需要注意的是：只需要迭代器++（已重载），即可实现遍历，无需费心是++还是--了。

string v;
std::iterator it=v.begin();//iterator即迭代器
for(;it<v.end();it++){
// write code here
}

我们以后还会再次遇见迭代器，而且会更加频繁，更加底层的理解。

还有一种访问方式，范围for访问，是在C++11才出现的新遍历方式。

string v("Hello world");
for(int i=0;i<v.size();i++){
    //C++98风格
}

for(char ch:v){
    //C++11风格
}

如此访问有一个好处，就是不必再担心什么时候加加，冒号前的ch即在字符串中读到的每个字符。但缺点在于，如果用范围for，我们就不能再跳着访问了，只能从头到尾全部一个一个访问。

值得庆幸的是，两种访问都可以使用，所以我们只需要挑更简便更熟悉的搭配使用即可。

2.4string的修改操作

访问对应的修改必不可少。

push_back(char c); //尾插一个字符c

append(string str); //尾插一个字符串（有大量重载函数）

operator+=(string str); //尾插一个字符串，和append功能相同

c_str(); //返回一个C语言格式的字符串，即数组储存形式

find(char c); //从字符串起始开始寻找字符c，找到即返回位置，未找到，返回npos，即-1。

rfind(char c); //反向寻找字符串中的字符c，找到即返回位置，未找到返回npos，即-1。

substr(size_t pos , size_t len) //从pos位置开始截取长度为len的字符串。

2.5string的非成员函数

operator+ //返回一个叠加后的字符串，但尽量少用

operator>> //输入运算符重载

operator<< //输出运算符重载

getline //获取一行字符串，只有遇到换行才会停止，可以用于接受带空格的字符串

relational operators //字符串大小比较（包含==,!=,<=,>=,<,>）

这几个函数都比较好用，起到了替代手动书写的作用。

三、string的模拟实现

如果我们能从底层源码剖析，那么就可以更好地理解string。

于是我斗胆写了一份string的模拟实现（请务必不要当作真正源码来看待），供参考。

namespace show {
	const size_t string::npos = -1;
	class string {
	public:
		typedef char* iterator;
		string(const char* str = "") {
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		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(_size, s._size);
			std::swap(_capacity,s._capacity);
			std::swap(_str , s._str);
		}
		string& operator=(const string& s) {
			if (_str != s._str) {
				delete[] _str;
				_size = s._size;
				_capacity = s._capacity;
				_str = new char[_capacity + 1];
				strcpy(_str, s._str);
			}
			return *this;
		}
		~string() {
			if (_str) {
				delete[] _str;
				_str = nullptr;
				_size = _capacity = 0;
			}
		}
		iterator begin() {
			return _str;
		}
		iterator end() {
			return _str + _size;
		}
		void reserve(size_t n) {
			if (n > _capacity) {
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[]_str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char c) {
			if (_size == _capacity) {
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}

		string& operator+=(char c) {
			push_back(c);
			return*this;
		}

		void append(const char* str) {
			size_t len = strlen(str);
			if (_size + len > _capacity) {
				reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
			}
			strcpy(_str + _size, str);
			_size=_size + len;
		}

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

		void clear() {
			_size = 0;
			_str[0] = '\0';
		}
		const char* c_str()const {
			return _str;
		}
		size_t size()const{
			return _size;
		}

		size_t capacity()const{
			return _capacity;
		}

		bool empty()const{
			return _size == 0;
		}

		void resize(size_t n, char c = '\0') {
			if (n > _capacity) {
				reserve(n);
				for (int i = _size; i < n; i++) {
					_str[i] = c;
				}
			}
			else {
				_size = n;
			}
		}
		char& operator[](size_t index) {
			assert(index < _size);
			return _str[index];
		}

		const char& operator[](size_t index)const {
			assert(index < _size);
			return _str[index];
		}

		bool operator<(const string& s) {
			return strcmp(c_str(), s.c_str()) < 0;
		}

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

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

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

		bool operator==(const string& s) {
			return strcmp(c_str(), s.c_str()) == 0;
		}

		bool operator!=(const string& s) {
			return !(*this == s);
		}
		size_t find(char c, size_t pos = 0) const {
			assert(pos < _size);

			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}

			return npos;
		}
		size_t find(const char* s, size_t pos = 0) const {
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, s);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}
		string& insert(size_t pos, char c) {
			assert(pos <= _size);

			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			// 挪动数据
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}

			_str[pos] = c;
			++_size;
		}

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

			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				// 大于2倍，需要多少开多少，小于2倍按2倍扩
				reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
			}

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

			for (size_t i = 0; i < len; i++)
			{
				_str[pos + i] = str[i];
			}

			_size += len;
		}
		string& erase(size_t pos, size_t len) {
			assert(pos < _size);

			if (len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				for (size_t i = pos + len; i <= _size; i++)
				{
					_str[i - len] = _str[i];
				}

				_size -= len;
			}
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
		static const size_t npos = -1;
	};
}

本篇内容到此结束，谢谢大家的观看！

觉得写的还不错的可以点点关注，收藏和赞，一键三连。

我们下期再见~

往期栏目：

C++学习指南（一）——C++入门基础-CSDN博客

C++学习指南（二）——类和对象-CSDN博客

C++学习指南（三）——模板_模板显示实例化-CSDN博客