『C++初阶』第五章--- string

Dklau-c

已于 2024-06-08 12:51:22 修改

阅读量991

点赞数 19

分类专栏： C++初阶知识文章标签： c++ 开发语言 c语言面试

于 2024-06-08 12:49:04 首次发布

本文链接：https://blog.csdn.net/m0_54443558/article/details/139530328

版权

C++初阶知识专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. 为什么学习string类?

1.1 C语言中的字符串

C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问

2. 标准库中的string 类

2.1 string类

string 是表示字符串的字符串类
该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作
string在底层实际是： basic_string 模板类的别名，typedef basic_string<char, char_traits,allocator> string;
不能操作多字节或者变长字符的序列。

在使用string类时，必须包含#include头文件以及using namespace std;

2.2 string 类的常用接口说明

1.string类对象的常见构造

函数名称	功能说明
string() （重点）	构造空的string类对象，即空字符串
string(const char* s) (重点)	用 C-string 来构造string类对象
string（size_t n, char c）	string类对象中包含n个字符c
string（const string&s）（重点）	拷贝构造函数

void Test1()
{
	string s1;    // 构造空的string 对象s1
	string s2("hello string"); //用C-string 格式字符串构造string类对象s2
	string s3(s2);  // 拷贝构造s3
	string s4(5, 'C');    // 构建对象中包含5个字符C

}

2. string类对象的容器操作

函数名称	功能说明
size（重点）	返回字符串有效字符长度（不包含'\0'的长度）
length	返回字符串有效字符长度（不包含'\0'的长度）
capacity	返回空间总大小
empty（重点）	检测字符串释放为空串，是返回true，否则返回false
clear（重点）	清空有效字符
reserve（重点）	为字符串预留空间
resize（重点）	将有效字符的个数改为n个，多出的空间用字符c填充

注意：

size（）与length（）方法底层实现原理完全相同，引入size（）的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size（）。
clear（）只是将stirng中有效字符清空，不改变底层空间大小。
resize（size_t n）与resize（size_t n, char c）都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时； resize（n）用0来填充多出的元素空间，resize(size_t n, char c) 用字符c 来填充多出的元素空间。注意： resize 在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减小，底层总大小不变。
reserve（size_t res_arg=0）：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小

3. string类对象的访问及遍历操作

函数名称	功能说明
operator[](重点)	返回pos位置的字符，const string类对象调用
begin + end	begin获取第一个字符的迭代器+end获取最后一个字符下一个位置的迭代器
rbegin + rend	rbegin获取最后一个字符的迭代器+ rend获取第一个字符的迭代器
范围for	C++支持更加简洁的范围foir的新遍历方式

4. string类对象的修改操作

函数名称	功能说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符串
operator+=(重点)	在字符串后追加字符串str
C_str(重点)	返回C格式字符串
find+npos(重点)	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

注意：

在string尾部追加字符时，s.push_back(c)/ s.append(1,c)/ s+='c' 三种的实现方式差不多，一般情况下string的+=操作用的比较多，+=操作不仅可以链接单个字符，还可以连接字符串。
对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

string的相关测试代码

void Test2()
{
	string s("hello string"); //用C-string 格式字符串构造string类对象s2
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;
	// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间大小
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;
	// 将s中有效字符个数增加到10个，多出位置用‘a’ 进行填补
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;
	//将s中有效字符个数增加到15个，多出位置用缺省值‘\0’ 进行填补
	s.resize(15);   //只是在原基础上增加到15个，原来的元素不会清空
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;
	//将s中有效字符个数增加到比capacity更大时，capacity的个数也会变大
	s.resize(20);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;
	//将s中有效字符个数缩小到5个,缩小时，capacity大小不发生变化
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;
}
void Test3()
{
	string s;
	// 测试reserve是否会改变string中有效元素个数   
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	//需要注意的是，reserve后面的值，执行后并非一定是string的capacity的大小
	cout << endl;
	// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;
	//答案是不会的
}
//可以利用reserve预先开辟空间来提高插入数据的效率，避免增容带来的开销

void TestPushBack()
{
	string s;
	size_t sz = s.capacity();
	cout << "maing s grow:\n";
	int begin = clock();
	for (int i = 0;i< 100000000; i++)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed" << sz << endl;

		}
	}
	int end = clock();
	cout << end - begin << endl;
}
//因为扩容也需要时间消耗，所以如果提前已经直到string中大概要放多少个元素，可以提前将string中空间设置好
void TestPushBackReserve()
{	
	string s;
	size_t sz = s.capacity();
	s.reserve(100000000);
	cout << "maing s grow:\n";
	s.reserve(100000000);
	int begin = clock();
	for (int i = 0;i< 100000000; i++)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed" << sz << endl;

		}
	}
	int end = clock();
	cout << end - begin << endl;

}
// string的遍历
// begin()+ end() for+[] 范围for
// 注意： string遍历时使用最多的还是for+下标 或者 范围for（C++11后才支持）
void Test5()
{
	string s1("hello Bit");
	// for+[]
	for (int i = 0; i < s1.size(); i++)
	{
		cout << s1[i];
	}
	cout << endl;
	// begin()+end() 遍历
	for (auto it = s1.begin(); it < s1.end(); it++)
	{
		cout << *it;
	}
	cout << endl;
	//范围for
	for (auto it : s1)
	{
		cout << it;
	}
	cout << endl;
}
void Test4()
{
	string s1("hello Bit");
	const string s2("Hello Bit");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;
	s1[0] = 'H';
	cout << s1 << endl;
	//  s2[0] = 'h';  因为s2 为const类型对象不能修改

}

// 测试string；
// 1， 插入（拼接）方式： push_back append operator+=
// 2.  正向和反向查找: find() + rfind();
// 3.  截取字串： substr();
// 4.  删除: erase()

void Test6()
{
	string str;
	str.push_back(' ');    // 在str后插入一个空格
	str.append("hello");   // 在str后追加一个字符"hello"
	str += 'b';			   //  在str后追加一个字符‘b’
	str += "it";			// 在str后追加一个字符串"it"
	cout << str << endl;
	cout << str.c_str() << endl;  

	//获取file的后缀
	string file("string.cpp");
	size_t pos = file.rfind('.');
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;

	// npos是string里面的一个静态成员变量
	// static const size_t npos=-1;

	//  取出 url中的域名
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos)
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/');
	string address = url.substr(start, finish - start);
	cout << address << endl;

	// 删除url 的协议前缀
	pos = url.find("://");
	//url = url.substr(pos + 2); 
	url.erase(0, pos + 3);

	cout << url << endl;
}

5. string类非成员函数

函数名称	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>(重点)	输入运算符重载
operator<<(重点)	输出运算符重载
getline(重点)	获取一行字符串
relational operators(重点)	大小比较

6. vs和g++下string结构的说明

注意：下述结果后是在32位平台下进行验证，32位平台下指针占4个字节

vs下string的结构

string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体就是用来定义string中字符串的存储空间

当字符串小于16时，使用内部固定的字符数组来存放
当字符串长度大于等于16时，从堆上开辟空间

union _Bxty
{ // storage for small buffer or pointer to larger one
value_typ   _Buf[_BUF_SIZE];
pointer     _Ptr;
char _      Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。

其次：还有一个size_t 字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量

最后：还有一个指针做一些其他事情。

故总共占16+4+4+4+4 =28个字节

g++ 下string 的结构

g++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针来指向一块堆空间，内部包含了如下字段：

空间总大小
字符串有效长度
引用计数

struct _Rep_base
{
size_type     _M_length;
size_type     _M_capacity;
_Atomic_word  _M_refcount;
};

指向堆空间的指针，用来存储字符串

3. string类的模拟实现

3.1 经典的string类问题

上面已经对string类进行了简单的介绍，下面主要是模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题？

class String
	{
	public:
		//String()
		//		:_str(new char[1])
		//		{*_str = '\0';}
		//		
				//String(const char* str = "\0") 错误示范
				//String(const char* str = nullptr) 错误示范
		String(const char* str = "")
		{
			// 构造String类对象时，如果传递nullptr指针，可以认为程序非
			if (nullptr == str)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}
		~String()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
	private:
		char* _str;
	};
    // 测试
    void TestString()
    {
    String s1("hello bit!!!");
    String s2(s1);
    }

说明：上述string类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造，最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种按字节拷贝，共用同一个空间的按拷贝方式，称为浅拷贝。

3.2 浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进行操作时，就会发生访问违规的错误。

所以我们可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。

3.3 深拷贝

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照神拷贝方式提供的。

3.3.1 传统版写法的string类

class String
	{
	public:
		String(const char* str = "")
		{
			// 构造String类对象时，如果传递nullptr指针，可以认为程序非
			if (nullptr == str)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}
		String(const String& s)
			:_str(new char [strlen(s._str) +1])
		{
			strcpy(_str, s._str);
		}
		String& operator=(const String& s)
		{
			if (this != &s)
			{
				char* pstr = new char[strlen(s._str) + 1];
				strcpy(pstr, s._str);
				delete[] _str;
				_str = pstr;

			}
			return *this;
		}
		~String()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
	private:
		char* _str;
	};

3.3.2 现代版写法的string类

class String
	{
	public:
		String(const char* str = "")
		{
			// 构造String类对象时，如果传递nullptr指针，可以认为程序非
			if (nullptr == str)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}
		String(const String& s)
			:_str(nullptr)
		{						  
			String tmp(s._str);   // 因为直接交换，会改变原先s的_str的值，所以需要新构建一个新的string，来交换	
			swap(_str, tmp._str); 
		}
		String& operator=( String s)
		{
			swap(_str, s._str);   // 因为参数是形参，是值拷贝，所以可以直接交换，相当于编译器替我们完成了新建string的操作
			return *this;
		}

		//String& operator=(const String& s)
		//{
		//	if (this != &s)
		//	{
		//		String tmp(s._str);
		//		swap(_str, tmp._str);   // 交换后 tmp的_str指向的是原_str的位置，所以函数结束后析构的也就是原_str
		//		_str = tmp._str;

		//	}
		//	return *this;
		//}
		~String()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
	private:
		char* _str;
	};

3.3 写时拷贝（了解）

写时拷贝就是一种拖延症，是在浅拷贝的基础上增加了引用计数的方式来实现的。

引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

写时拷贝

写时拷贝的缺陷

3.4 string类的模拟实现

string类的模拟实现

//———————— string.h

namespace bit
{
	class string
	{
	public:

		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;

		string(const char* str="");  
		string(const string& s);
		~string();
		size_t size() const;
		size_t capacity() const;
		bool empty()const;

		char* c_str() const;
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;
		string& operator= (const string& s);
		string operator+ (char ch);
		string operator+ (const char* str);
		string operator+ (const string& s);
		string& operator+= (const string& str);
		string& operator+= (const char* str);
		string& operator+= (char ch);
		bool operator> (const string& s);
		bool operator>= (const string& s);
		bool operator< (const string& s);
		bool operator<= (const string& s);
		bool operator== (const string& s);
		bool operator!= (const string& s);
		void reserve(size_t n=0);
		void resize(size_t n);
		void resize(size_t n, char c);
		void push_back( char c);

		void swap(string& s);
		void insert(size_t pos,  char ch);
		void insert(size_t pos,  const char* ch);
 		void erase(size_t pos=0, size_t len = npos);
		void append(const char* str);
		string substr(size_t pos=0, size_t len = npos);
		void clear();



		size_t find(char ch, size_t pos=0);
		size_t find(const char* ch, size_t pos = 0);

	


	private:
		char* _str;
		size_t _size;
		size_t _capacity;

	    const static  size_t npos;
	};
}

 istream& operator>>(istream is, bit::string& str);
 ostream& operator<<(ostream os, bit::string& str);

//——————————————————————————————————————————————————
// string.cpp

namespace bit
{
	const  size_t string::npos = -1;


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

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

	string::string(const string& s)
		:_capacity(s._capacity)
	{
		_str = new char[_capacity+ 1];
		_size = s._size;
		strcpy(_str, s._str);

	}
	string::~string()
	{
		if (_str) delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	char* string::c_str() const
	{
		return _str;
	}
	size_t string::size() const
	{
		return _size;
	}
	size_t string::capacity() const
	{
		return _capacity;
	}
	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
	const char& string::operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}
	size_t string::find(const char ch, size_t pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch) return i;
		}
		return npos;
	}
	void string::clear()
	{
		_str[0] = '\0';
		_size = 0;
	}
	void string::push_back(char c)
	{
		insert(_size , c);
	}
	void string::append(const char* str)
	{
		insert(_size, str);

	}

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

	size_t string::find(const char* ch, size_t pos)
	{
		char* p = strstr(_str + pos, ch);
		return p - _str;
	 }

	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	void string::insert(size_t pos, char ch)    
	{
		assert(pos <= _size);

		if (_size == _capacity)
		{
			size_t New = _capacity == 0 ? 4 : 2 * _capacity;
			this->reserve(New);
		}
		size_t end = _size+1;    //这里如果写end=_size，下面也相应改完之后，那么当pos==end时，_str的最后一个位置'\0'就会被替换，所以如果要怎么写的话，最后需要根据条件在设置一个'\0'
								 //  正常的插入，'\0'也需要跟着移动，所以后移范围应该是_size+1~0，所以最好写成end=_size+1,这样'\0'也会后移
		while (end > pos)
		{
			_str[end] = _str[end-1];
			end--;
		}
		_str[pos] = ch;
		_size++;
	}
	void string:: insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
		if (_size + len > _capacity)  reserve(_size + len);
		size_t end = _size+len;
		while (end > pos + len - 1)
		{
			_str[end] = _str[end - len];
			end--;
		}
		memcpy(_str+pos, str, len);
		_size += len;
	}


	void string::resize(size_t n)
	{
		if (n > _capacity) this->reserve(n);
		_size = n;
		_str[_size + 1] = '\0';
		size_t end = n;
		while (_str[end] != '\0')
		{
			_str[end] = '\0';
			end--;
		}
		_str[end] = '\0';
	}
	void string::resize(size_t n, char c)
	{
		if (n > _capacity) this->reserve(n);
		_size = n;
		_str[_size + 1] = '\0';
		size_t end = n;
		while (_str[end] != '\0')
		{
			_str[end] = c;
			end--;
		}
		_str[end] = c;
	}
	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 + pos + len);
			_size -= len;
		}
	}
	string string::substr(size_t pos , size_t len)
	{
		assert(pos < _size);
		//if ((pos + len) >= _size)   //pos+len >=_size 会出错， 因为size_t len默认为npos（-1） 再加上一个数会变回0 开始循环
		if (len >= _size - pos)
		{	
			string tmp(_str + pos);
			return tmp;
		}
		else
		{
			string tmp;
			tmp.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				tmp += _str[pos+i];
			}

			return tmp;

		}
	}

	string& string::operator= (const string& s)
	{
		if (this != &s)
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
			_capacity = s._capacity;
			_size = s._size;
		}
		return *this;
	}
	string string::operator+ (const string& s)
	{
		string tmp = *this;
		tmp.append(s._str);
		return tmp;
	}
	string string::operator+ (char ch)
	{
		string tmp = *this;
		tmp.push_back(ch);
		return tmp;
	}
	string string::operator+ (const char* str)
	{
		string tmp = *this;
		tmp.append(str);
		return tmp;
	}

	string& string::operator+= (const string& str)
	{
		append(str._str);
		return *this;

	}

	string& string::operator+= (const char* s)
	{
		append(s);
		return *this;
	}
	string& string::operator+= (char ch)
	{
		push_back(ch);
		return *this;
	}
	bool string::operator> (const string& s)
	{
		int t = strcmp(_str, s._str);
		if (t) return true;
		else return false;
	}
	bool string::operator== (const string& s)
	{
		return strcmp(_str, s._str) == 0;
	}
	bool string::operator>= (const string& s)
	{
		return *this > s && *this == s;
	}
	bool string::operator< (const string& s)
	{
		return !(*this > s);
	}
	bool string::operator!= (const string& s)
	{
		return !(*this == s);
	}
	bool string::operator<= (const string& s)
	{
		return *this < s && *this == s;
	}
	 istream& operator>>(istream is, string& str)
	{
		 str.clear();
		 char ch = is.get();
		 while (ch != '\n' && ch != ' ')
		 {
			 str += ch;
			 ch = is.get();
		 }
		 return is;
	}
	  ostream& operator<< (ostream os, string& str)
	  {
		  for (int i = 0; i < str.size(); i++)
		  {
			  os << str[i];
		  }
		  return os;
	  }

}