初识C++: string类【标准库里的string】【string类的模拟实现】

阿政一号

已于 2024-07-31 16:34:43 修改

阅读量795

点赞数 23

文章标签： c++ 算法 windows c语言

于 2024-07-29 21:31:22 首次发布

本文链接：https://blog.csdn.net/2301_81699364/article/details/140753524

版权

1.3.6vs和g++下string结构的说明

二.string类的模拟实现

2.1构造函数，赋值运算符重载，析构函数的模拟实现

2.7 find insert erase substr

2.8<<和>>

关于string类，可以先看一下这个文档string文档。

一.标准库里的string

1.1auto关键字

（1）在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

（2）用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

（3）当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

	// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
	auto cc = 3, dd = 4.0;

（4）auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

不能做函数的参数

auto可以自动的识别类型，做返回值是一种牺牲可读性的方式：

auto func2()
{
	return 3;
}

（5）auto不能直接用来声明数组

1.2范围for

（1）对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

（2）范围for可以作用到数组和容器对象上进行遍历

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	for (auto& e : array)//自动识别类型
		e *= 2;
	for (auto e : array)
		cout << e << ' ';
	cout << endl;
	string str("hello world");
	for (auto ch : str)
	{
		cout << ch << ' ';
	}
	cout << endl;
	return 0;
}

（3）范围for的底层很简单，容器遍历实际就是替换为迭代器。

这三个等价：

string str("hello world");
for (auto ch : str)
{
	cout << ch << ' ';
}
cout << endl;
//这个for循环就是上面范围for的底层
for (auto ch = str.begin(); ch < str.end(); ch++)
{
	cout << *ch << ' ';
}
cout << endl;
//这里的auto就是string::iterator
for (string::iterator ch = str.begin(); ch < str.end(); ch++)
{
	cout << *ch << ' ';
}

1.3string类的常见接口

1.3.1string类对象的常见构造

string()	构造空的string类对象，即空字符串
string(const char* s)	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s)	拷贝构造函数

	string s1;
	string s2("abcdefg");
	string s3(5, 'c');
	string s4(s2);

这里只是几个常用的，C++11中更新了9个：

1.3.2string对象的容量操作

size	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty	检测字符串是否为空串，是返回true，否则返回false
clear	清空有效字符
reserve	为字符串预留空间
resize	将有效字符的个数该成n个，多出的空间用字符'\0'填充

string s("hello world");
cout << s.size() << endl;//有效字符长度
cout << s.length() << endl;//有效字符长度
cout << s.capacity() << endl;//空间总大小
cout << s << endl;

// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;

// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;

// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;

// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;

注意：

（1）size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。

（2）clear()只是将string中有效字符清空，不改变底层空间大小。

（3）resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

（4）reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

1.3.3类对象的访问及遍历操作

operator[]	返回pos位置的字符，const string类对象调用
begin+end	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
rbegin+rend	与begin+end刚好相反
范围for	C++11支持更简洁的范围for的新遍历方式

operator[]当成数组就行，比如在遍历的时候：

int main()
{
	string s1("hello world");
	for (int i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << ' ';
	}
	return 0;
}

之后是begin+end和rbegin+rend：

int main()
{
	string s1("hello world");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;
	// string::reverse_iterator rit = s.rbegin();
	// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
	auto rit = s1.rbegin();
	while (rit != s1.rend())
	{
		cout << *rit;
		rit++;
	}
	return 0;
}

打印出：

范围for就跟上面的一样。

1.3.4string类对象的修改操作

push_back	在字符串后插入字符
append	在字符串后追加字符串
operator+=	在字符串后追加字符串
c_str	返回字符串
find+npos	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

对于前四个：

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

rfind：

	// 获取file的后缀
	string file("string.cpp");//rfind从后面开始查找
	size_t pos = file.rfind('.');//返回.的位置
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;

find是从前面开始查找，查找失败返回npos。 npos是string里面的一个静态成员变量：static const size_t npos = -1。

substr：

string str = "We think in generalities, but we live in details.";

string str2 = str.substr(3, 5);     // "think"

size_t pos = str.find("live");      // 返回live的位置

string str3 = str.substr(pos);     // 从pos位置到最后

cout << str2 << '\n' << str3 << '\n';

1.3.5string类非成员函数

operator+	尽量少用，传值返回，调用拷贝效率低
operator>>	输入运算符重载
operator<<	输入运算符重载
getline	获取一行字符串
relational operators	大小比较

这几个就比较简单了，关于我提到的这些函数的定义，还是没有提到的都可以在上面的那个文档里查看string文档。

1.3.6vs和g++下string结构的说明

在不同的编译环境下，对于string定义的结构也有所不同：

vs下string的结构：

string总共占28个字节，内部结构稍微复杂一点。

首先是有一个联合体，联合体用来定义string中字符串的存储空间：

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

union _Bxty

{ // storage for small buffer or pointer to larger one

 value_type _Buf[_BUF_SIZE];
 pointer _Ptr;
 char _Alias[_BUF_SIZE]; // to permit aliasing

} _Bx;

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

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

故总共占16+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;
};

二.string类的模拟实现

2.1构造函数，赋值运算符重载，析构函数的模拟实现

class String
{
public:
	//默认构造函数
	//不能写成String(const char* str = nullptr)
	//如果写成这样我们初始化一个无参的s1会用这个缺省值，打印会出现错误，库里的不会
	String(const char* str="")//注意这里缺省值，""里本身就有\0.
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_size + 1];//多开一个给\0
		strcpy(_str, str);
	}
	//拷贝构造函数的传统写法
	//深拷贝
	String(const String& s)
	{
		_str = new char[s._capacity + 1];
		_size = s._size;
		_capacity = s._capacity;
		strcpy(_str, s._str);
	}
	//拷贝构造函数的现代写法
	void swap(String& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	String(const String& s)
		: _str(nullptr)
		, _size(0)
		, _capacity(0)
	{
		String tmp(s._str);
		swap(tmp);
	}
	//赋值运算符重载的传统写法
	String& operator=(const String& s)
	{
		if (this != &s)//s1==s1
		{
			delete[] _str;//先把原来的空间释放
			_str = new char[s._capacity + 1];//重新开一个可以放下s的空间，+1是为了放'\0'
			_size = s._size;
			_capacity = s._capacity;
			strcpy(_str, s._str);//依次赋值
		}
		return *this;
	}

	//赋值运算符重载的现代写法
	String& operator=(const String& s)
	{
		String tmp = s;
		swap(tmp);
		return *this;
	}

	//析构函数
	~String()
	{
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

2.1.1深拷贝与浅拷贝

深拷贝：

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

浅拷贝：

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