【C++】拆分详解 - string类


一、为什么学习string类?

  • C语言中,字符串是以’\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。
  • 在OJ中,有关字符串的题目基本以string类的形式出现,而且在常规工作中,为了简单、方便、快捷,基本都使用string类,很少有人去使用C库中的字符串操作函数。

二、标准库中的string类

1. 定义

string类的文档介绍注:此处及下文部分,蓝色下划线标识文本均为超链接,点击即可跳转

  1. 字符串是表示字符序列的类
  2. 标准的字符串类提供了对此类对象的支持,其接口类似于标准字符容器的接口,但添加了专门用于操作单字节字符字符串的设计特性。
  3. string类是使用char(即作为它的字符类型,使用它的默认char_traits和分配器类型(关于模板的更多信息,请参阅basic_string)。
  4. string类是basic_string模板类的一个实例,它使用char来实例化basic_string模板类,并用char_traits和allocator作为basic_string的默认参数(关于更多的模板信息请参考basic_string)。
  5. 注意,这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列,这个类的所有成员(如长度或大小)以及它的迭代器,将仍然按照字节(而不是实际编码的字符)来操作。

总结:

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

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

2. 常用接口说明

2.1 构造

函数名称(constructor)功能说明
string()default】默认构造,构造空string类对象即空字符串
string(const char* s)from c-string】用C字符串构造string类对象
string(size_t n, char c)fill】用多个相同字符 ‘c’构造
string(const string&s)copy】拷贝构造
// 1.测试string构造相关的接口
void text_string1()
{
	//常用
	string s1; //构造空string类对象
	string s2("Hello World!"); //用c字符串构造
	string s3(s2); //拷贝构造

	//不常用 了解即可
	string s4(s2, 2, 5); //从s2 下标2的位置开始,选择其及往后5个位置 拷贝构造s4
	string s5(s2, 2); //同上,第三个参数使用缺省值npos(结合相关文档),从下标2位置开始,有多少拷贝多少
	string s6(s2, 2, 30); //同上,第三个参数传参值大于 指定对象总长度时,也是有多少拷贝多少
	string s7("Hello World!", 5); //给定c字符串,从头顺序拷贝 指定个数的字符
	string s8(10, 'x'); //用指定个数 的指定字符 填充构造

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;
	cout << s6 << endl;
	cout << s7 << endl;
	cout << s8 << endl;
}

2.2 容量操作

函数名称功能说明
size返回字符串有效字符长度
length返回字符串有效字符长度
capacity返回空间总大小(不含’/0’占据的一个空间)
empty检测字符串是否为空串,是返回true,否则返回false
clear清空有效字符
reserve更改capacity值,为字符串预留空间
① 提前开空间(已知所需空间大小时),避免多次扩容消耗
② reserve后,要使用resize才能使用 [ ]下标访问( [ ]会检查size值 )
resize更改size值,调整有效字符个数

在这里插入图片描述
在这里插入图片描述

注意:

  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在改变元素个数时,如果是将元素个数增多,可能会改变底层容量的大小,如果是将元素个数减少,底层空间总大小不变。
// 2.测试string容量相关的接口  size/clear/resize
void text_string2()
{
	//1. 注意:string类对象支持直接用cin和cout进行输入和输出
	cout << "下方为1:" << endl;
	string s("hello, bit!!!");
	cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//2. 将s中的字符串清空,注意清空时只是将size清零,不改变底层空间的大小
	cout << "下方为2:" << endl;
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;

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

	//4. 将s中有效字符个数增加到15个,多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	cout << "下方为4:" << endl;
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//5. 将s中有效字符个数缩小到5个 -> 删除
	cout << "下方为5:" << endl;
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
	cout << endl;

	//6. 测试reserve是否会改变string中有效元素个数 -> 不会,单纯扩容
	cout << "下方为6:" << endl;
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;

	//7. 测试reserve参数小于string的底层空间大小时,是否会将空间缩小 -> 不会,无变化
	cout << "下方为7:" << endl;
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << endl;
}

// 利用reserve提高插入数据的效率,避免增容带来的开销
//====================================================================================
void text_PushBack() //多次扩容,开销大
{
	string s;
	size_t cap = s.capacity();
	cout << "无reserve的扩容情况:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (cap != s.capacity())
		{
			cap = s.capacity();
			cout << "capacity changed: " << cap << endl;
		}
	}
}

void text_PushBackReserve() //减少扩容次数,节省开销
{
	string s;
	s.reserve(100);
	size_t cap = s.capacity();
	cout << "有reserve的扩容情况:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (cap != s.capacity())
		{
			cap = s.capacity();
			cout << "capacity changed: " << cap << '\n';
		}
	}
}

2.3 访问及遍历操作

函数名称功能说明
operator[] 类似数组的下标访问,返回pos位置的字符,const string类对象调用
begin + endbegin:返回一个迭代器指向 字符串第一个字符位置
end:返回一个迭代器指向 最后一个字符的下一个位置
rbegin + rendrbegin:返回一个迭代器指向 最后一个字符位置,即反向begin
rend:返回一个迭代器指向 第一个字符的位置,即反向end
范围forC++11支持的更简洁的新遍历方式
// string的访问  s[]
void text_string3()
{
	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';   代码编译失败,因为const类型对象不能修改
}

//string的遍历 -> begin()+end()   for+[]  范围for
// 注意:string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
void text_string4()
{
	string s("hello Bit");
	// 3种遍历方式:
	// 需要注意的以下三种方式除了遍历string对象,还可以遍历是修改string中的字符,
	// 另外以下三种方式对于string而言,第一种使用最多
	// 1. for+operator[]
	for (size_t i = 0; i < s.size(); ++i)
		cout << s[i] << " ";
		//cout << s1.operator[](i) << endl;
		cout << endl;
		
	// 2.迭代器
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	// string::reverse_iterator rit = s.rbegin();
	// C++11之后,直接使用auto定义迭代器,让编译器推到迭代器的类型
	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	
	// 3.范围for
	for (auto ch : s)
		cout << ch << endl;
}

2.4 修改操作

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

注意:

  1. 在string尾部追加字符时,s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多,一般情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可以连接字符串。
  2. 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve把空间预留好,避免多次扩容造成消耗
// 测试string:
// 1. 插入(拼接)方式:push_back  append  operator+= 
// 2. 正向和反向查找:find() + rfind()
// 3. 截取子串:substr()
// 4. 删除:erase
void text_string5()
{
	//1. 插入与追加
	cout << "下方为1:" << endl;
	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;   // 以C语言的方式打印字符串
	cout << endl;

	//2. 获取file的后缀
	cout << "下方为2:" << endl;
	string file("string.cpp");
	size_t pos = file.rfind('.');	// pos缺省值为npos,是string里面的一个静态成员变量
									// static const size_t npos = -1; 由于为无符号数,实际为整形最大值,
									// 效果为从字符串最末尾开始往前找
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;
	cout << endl;

	//3. 取出url中的域名
	cout << "下方为3:" << endl;
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find(':'); //pos缺省值为0,从字符串第一个字符位置开始往后找
	if (start == string::npos) //find/rfind 未找到指定字符时 返回npos
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;
	cout << endl;

	//4. 删除url的协议前缀
	cout << "下方为4:" << endl;
	pos = url.find("://");
	url.erase(0, pos + 3); //删除
	cout << url << endl;
	cout << endl;
}

2.5 非成员函数

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

上面的几个接口大家了解一下,下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作,这里不一一列举,大家在需要用到时不明白了查文档即可。

三、OJ练习自测

  1. 仅仅反转字母

class Solution {
public:
    bool isLetter(char ch)
    {
        if(ch >='a' && ch <= 'z')
            return true;
        if(ch >= 'A' && ch <= 'Z')
            return true;

        return false;
    }
    string reverseOnlyLetters(string s) {
        if(s.empty())
            return s;
        size_t begin = 0;
        size_t end = s.size()-1;
        while(begin < end)
        {
            while(begin < end && !isLetter(s[begin]))
                ++begin;
            while(begin < end && !isLetter(s[end]))
                --end;

            swap(s[begin],s[end]);
            ++begin;
            --end;
        }
        return s;
    }
};

思路:
  类似快排的单趟,从两边往中间找,跳过非字母,均字母时交换
注意:
 ① 手动实现判断是否为字母函数 isLetter
 ② 特殊判断:给定串为空时,提前返回
 ③ 交换后要更新begin,end

  2. 找字符串中第一个只出现的字符

class Solution {
public:
    int firstUniqChar(string s) {
        int count[128] = {0};
        for(int i = 0;i<s.size();i++)
        {
            count[s[i]]++; //s[i]会转换为ascll码值,具有唯一标识数
                           // i标识的是字符串的下标
        }
        for(int i = 0;i<s.size();i++)
        {
            if(count[s[i]] == 1)
                return i;
        }
        
        return -1;
    }
};

思路:
  类似 计数排序,利用字符的Ascll码值具有唯一标识
注意:
 ① Ascll码值只有128个
 ② count[s[i]]s[i] 会被自动转换成对应的Ascll码值

  3. 字符串最后一个单词长度

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

int main() {
    string s;
    while(getline(cin, s)) //多组输入,题目要求不为空串,则为空时结束
    {
        size_t pos = s.rfind(' ');
        cout << s.size()-pos-1 << endl;
    }
   
    return 0;
}

思路:
  因单词间使用空格隔开,所以从后往前找空格即可定位最后一个单词位置(找标识)
注意:
 ① cin 无法读取空格,使用 getline

  4. 验证回文串

class Solution {
public:
    bool IsLetterOrNumber(char ch)
    {
        if(ch>='A' && ch <='Z'
        || ch>='a' && ch<='z'
        || ch>='0' && ch<='9')
            return true;
        return false;
    }
    bool isPalindrome(string s) {
        for(auto& ch : s)
        {
            //将大写字符转为小写
            if(ch>='A' && ch<='Z')
                ch += 32;
        }
        //验证是否回文
        int begin = 0;
        int end = s.size()-1; //不能用size_t,串有可能为空,则为负数
        while(begin < end)
        {
            while(begin < end && !IsLetterOrNumber(s[begin]))
                ++begin;
            while(begin < end && !IsLetterOrNumber(s[end]))
                --end;
            if(s[begin] != s[end])
                return false;
            ++begin;
            --end;
        }

        return true;
    }
};

思路:

  1. 创建新串,将符合要求的字符插入其中再验证回文
  2. 类似快排单趟,在原串上跳过不符合要求的字符,比较符合要求的

注意:
 ① 范围for 进行修改要传引用
 ② 下标不能用size_t 类型,有可能为负数

  5. 字符串相加

class Solution {
public:
    string addStrings(string num1, string num2) {
        string tmp;
        int cur1 = num1.size() - 1;
        int cur2 = num2.size() - 1;
        int next = 0;

        while (cur1 >= 0 || cur2 >= 0)
        {
            int x1 = cur1 >= 0 ? num1[cur1--]-'0' : 0;
            int x2 = cur2 >= 0 ? num2[cur2--]-'0' : 0;
            int sum = x1 + x2 + next;

            next = sum/10; //处理进位
            sum = sum % 10;

            //tmp.insert(0,1, sum + '0'); 头插时间复杂度为 N^2,则可先尾插再逆置
            tmp += (sum+'0'); 
        }
          
        if(next == 1) //最后一位为进位,要格外判断加上进位1
            tmp += '1';
            
        reverse(tmp.begin(), tmp.end());
        return tmp;
    }
};

思路:

  • 依次取出各个位置的字符转为整型进行运算,大于等于10的进位

注意:
 ① 短串前方 可看做数字0填充(不需要考虑谁长谁短,否则处理起来非常麻烦)
 ② 处理进位的方式
 ③ 边界情况:最后一位为进位
 ④ 优化:头插效率低,则先尾插再逆置

四、string类的模拟实现

0. 整体框架

//模拟实现string类
namespace Mystr //用命名空间封装,以免和std中的string冲突,调用方式如主函数
{
	class string
	{
	public:
		string(const char* str = "");
		string(const string& s);
		~string();
		string& operator=(string& s);
		const char* c_str() const;
	//...各类函数接口

	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
		//const static size_t npos = -1; √ 只有整型可以用缺省值
		//const static double npos = -1.0; ×
	};
}

int main()
{
	Mystr::string s1 = "abc"; //调用指定命名空间域的模拟string类
	s1.push_back('a');
	//...
	return 0;
}

1. 构造 / 析构 / 拷贝 / 赋值

namespace bit
{
	const size_t string::npos = -1;
	
//1.0 构造(带参)
	/* V1版本 三个strlen效率低
	string::string(const char* str)
		:_str(new char[strlen(str) + 1])
		,_size(strlen(str))
		,_capacity(strlen(str))
	{
		strcpy(_str, str);
	}
	*/
	/* V2版本 忘记初始化列表初始化顺序=成员变量的声明顺序 
	string::string(const char* str)
		:_size(strlen(str))
		, _str(new char[_size + 1])
		, _capacity(_size)
	{
		strcpy(_str, str);
	}
	*/
	/* V3最终版 初始化列表与函数体内赋值 相结合 */
	string::string(const char* str)
		:_size(strlen(str))
	{
		_str = (new char[_size + 1]);
		_capacity = _size;
		strcpy(_str, str);
	}

//1.1 构造(无参)
	/* V1版本 不开空间× 
	string::string()
	{
		_str = nullptr;
		_size = _capacity = 0;
	}
	*/
	/*V2版本 无参和带参分开写
	string::string()
	{
		_str = new char[1]{ '\0' };
		_size = _capacity = 0;
	}
	*/
	/*V3版本 和构造带参V3版本一样,将全缺省和无参合二为一,声明处给缺省值即可*/

//1.2 拷贝构造(深拷贝,需要手动控制 开新空间)
	string::string(const string& s)
	{
		_str = new char[s._capacity];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	
//1.3 赋值运算符重载
	string& string::operator=(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;
	}

//1.4 析构
	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
}
  • 注释补充:

本文采用声明和定义分离的方式模拟string,注意事项如下(不分离的不用看):
 ① 声明和定义都用命名空间域包起来防止冲突,链接时会自动合并(同名namespace)
 ② 定义时要指定类域,否则会报错(函数名前加string::

  1.0 构造

思路:
 ① 开空间并赋值
 ② 更新_size,_capacity

问题(V1,V2版本):

  1. 多次使用strlen计算字符串长度,效率低
  2. 如果想复用已经初始化好的,需要保证声明顺序,容易出错不建议这种做法
    (初始化列表初始化顺序 = 成员变量的声明顺序)

  1.1 构造(无参)

  1. 是否要开空间? --> 必须开
     流输出 cout 打印 const char* 指针类型,不会像其他指针一样 打印指针本身的值,而是去打印指针指向的内容(字符串),即默认发生解引用,会去找到‘/0’才停止。
     而此时未开辟空间,为空指针,对空指针解引用会出错
  2. 可使用缺省参数将 全缺省和无参 合二为一
    ① 声明和定义分离:
     声明处写为 string(const char* str = ""); 定义处不变
    ② 不分离:
      定义处写

  1.3 赋值运算符重载

思路:
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_size,_capacity
优化:
 ① 判断是否为自己给自己赋值,自赋值时可不必开新空间

2. 增 删 查 改

namespace bit
{
//5. c_str
	const char* string::c_str() const
	{
		return _str;
	}

//6. size
	size_t string::size() const
	{
		return _size;
	}
	
//7. find
	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 string::find(const char* sub, size_t pos)//查找子串
	{
		char* p = strstr(_str + pos, sub); 
		return p - _str; //指针加减运算
	}
	
//8. operator[]
	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}

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

//9. 迭代器(用指针模拟)
	typedef char* iterator;
	typedef const char* const_iterator;
	
	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}
	//const版本
	string::const_iterator string::begin() const
	{
		return _str;
	}
	string::const_iterator string::end() const
	{
		return _str + _size;
	}

//10. reserve
	void string::reserve(size_t n)
	{
		if (n > _capacity) //一般不缩容
		{
			char* tmp = new char[n + 1];//多开一个给'/0'
			strcpy(tmp, _str);
			delete[] _str;
.
			_str = tmp;
			_capacity = n;
		}
	}

//11. push_back
	void string::push_back(char ch)
	{
		if (_size + 1 > _capacity)
		{
			//赋值运算符优先级最低,先进行三目运算符判断,最后赋值
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
			//reserve(_size + 1); //需要多少开多少,也可以如上多开空间适用于多次插入的情景
		}
	
		_str[_size] = ch;
		_str[_size + 1] = '/0';
		++_size;
	}
	//复用insert 版本
	void string::push_back(char ch)
	{
		insert(_size, ch);
	}

//12. append
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
	
		//strcat(_str, str); 效率低,要从头开始遍历找'/0'位置
		strcpy(_str + len, str);
		_size += len;
	}
	//复用insert 版本
	void string::append(const char* str)
	{
		insert(_size, str);
	}

//13. operator+=
	string& string::operator+=(char ch) //字符
	{
		push_back(ch);
	
		return *this;
	}
	
	string& string::operator+=(const char* str)//字符串
	{
		append(str);
	
		return *this; //要适用于连续赋值情景,返回左操作数
	}

//14. insert
	void string::insert(size_t pos, char ch)
	{
		assert(pos < _size);
	
		if (_size + 1 > _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
	/* 若为头插,即pos == 0,需注意一下两种写法
	写法1:循环结束条件为end<0,end起始位置为size,将end位挪给end后一位
		注意:
			①将end写为int类型
			②强转size类型为int
		原因:
			设计上为while循环结束条件为 end < 0,即最后一次挪动为_str[1] = _str[0],end--为-1,退出循环。
			但size_t为无符号整形,没有负数的概念,-1表示的是整形最大值,所以应该写为 注意①事项;
			且据C语言中所学,运算符两边操作数类型不同时,会发生类型提升:一般为类型小的向类型大的提升,
			int向size_t提升,所以用size赋值end时要写为 注意②事项
			
		//方法1 将end移向end后一位
		/*
		int end = _size; //end指向末尾位置'/0'位置,若指向有效字符的末字符位置,则会把'/0'覆盖掉,后续要手动加上
		while (end >= (int)pos)
		{
			_str[end + 1] = _str[end];
			--end;
		}
		*/
		//方法2 将end前一位移向end
		size_t end = _size + 1; //end指向'/0'后一位
		while (end >= pos-1)
		{
			_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);
		}
	
		//方法1 将end 移向 end+len位
		/*
		int end = _size;
		while (end >= (int)pos) //end > pos-1
		{
			_str[end + 1en] = _str[end];
			--end;
		}
		*/
		
		//方法2 将end-len 移向 end位
		size_t end = _size + len;
		while (end >= pos+len) //end > pos+len-1
		{
			_str[end] = _str[end - len];
			--end;
		}
	
		//memcpy(_str + pos, str,len); 都可以
		strcpy(_str + pos, str);
		_size += len;
	}

//15. erase
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
	
		// len大于后续字符个数时,有多少删多少
		if (len >= _size - pos)
		{
			_str[pos] = '/0'; //直接置'/0'
			_size = pos;
		}
		else
		{
			//移动覆盖
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}
//16. substr
	string string::substr(size_t pos, size_t len)
	{
		// 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[i] = _str[pos + i];
			}
	
			return sub;
		}
	}
}
//迭代器测试函数
void test_string2()
{
	string s3("hello world");
	for (auto ch : s3)
	{
		cout << ch << " ";
	}
	cout << endl;

	string::iterator it3 = s3.begin();
	while (it3 != s3.end())
	{
		cout << *it3 << " ";
		++it3;
	}
	cout << endl;
}

  2.0 迭代器

注意:
 ① 重载一般版本和const版本

  2.1 reserve

思路:
 ① 开新空间并赋值
 ② 释放旧空间
 ③ 更新_str,_capacity
注意:
 ① 一般不缩容,给定空间比现有空间小时,不变化

  2.2 push_back / append / operator+= / insert

思路:
 ① 检查容量(扩容)
 ② 插入
 ③ 更新
注意:
 ① 实现 insert 即可复用于 => push_back / append => +=
 ② 重载插入字符 和 字符串两个版本
 ③ insert 中 while循环的两种写法(‘/0’位 移向后一位,'/0’前一位移向 '/0’位)
 ④ 结束条件写法(> / >=
  ① > x 时,=x-1时 为最后一次进入循环
  ② >= x 时,=x时 为最后一次进入循环
  ③ <= x 时,=x时 为最后一次进入循环

在这里插入图片描述

  2.3 erase

思路:
 分两种情况,一为有多少删多少,二为删除指定位后指定个
 1. 直接在pos位 置’/0’ 并更新_size(相当于删除后续所有字符)
 2. 将指定位后的字符 移动覆盖到 pos位后

  2.4 substr

思路:
 分两种情况,一为有多少取多少,二为取指定位后指定个 为子串
 1. 直接用pos位的 指针构造子串(字符串指针指向首字符位置,相当于传入子串的指针)
 2. 从pos位开始,依次将指定个 赋值给新串

3. 非成员函数

namespace bit
{
	const size_t string::npos = -1;
//17. swap
	// s1.swap(s2)
	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	
//18. 各类运算符重载
	bool string::operator<(const string& s)const
	{
		return strcmp(_str, s._str) < 0;
	}
	
	bool string::operator==(const string& s)const
	{
		return strcmp(_str, s._str);
	}
	
	bool string::operator>(const string& s) const
	{
		return !(*this <= s);
	}
	
	bool string::operator>=(const string& s)const
	{
		return !(*this < s);
	}
	
	bool string::operator<=(const string& s) const
	{
		return *this < s || *this == s;
	}
	
	void string::clear()
	{
		_str[0] = '/0';
		_size = 0;
	}
	
	/*V1版本 
	istream& operator>>(istream& is, string& str)
	{
		str.clear();
		char ch;
		//cin >> ch; 无法读取含空格的串
		ch = is.get();
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
	
		return is;
	}*/
	
	/*V2版本 模拟缓冲区*/
	istream& operator>>(istream& is, string& str)
	{
		char buff[128];
		int i = 0;
		char ch = is.get();
		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)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			os << str[i];
		}
	
		return os;
	}
}

  3.0 npos

注意:
 ① 为静态成员变量,类内声明 类外定义,相当于全局变量
  【若整体声明和定义分离则需要在 .h 文件中声明,.cpp 文件中定义,避免多个源文件包含.h 时发生重定义】
 ② 一般不能在声明处给缺省值(给缺省值实际是给初始化列表使用的,而静态成员变量不走初始化列表)

  • 特例: const static int/size_t 类型变量 可以使用缺省值初始化

  3.1 swap

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

思路:
  手动交换各自的成员变量即可
问题:
  为什么std中含有 swap,string中还要再提供?又为什么提供两个?
  ① std中的 swap为模板(如上图三),代价太大(需要一次拷贝构造,两次赋值,反复开辟、释放空间)
  ② string的成员函数swap是 针对string类对象的优化写法,而非成员函数swap 是设计者怕使用者直接调用std中的模板,手动对该模板进行的实现(有现成的用现成的),其内部实际上还是调用的成员函数swap(套娃)。

string s1, s2;
s1.swap(s2); //调用成员函数 swap
swap(s1, s2); //调用非成员函数 swap(如果没有对模板中的string类型 进行实现为非成员函数,则会调用std中的模板)

  3.2 比较运算符重载

注意:
 ① 只需实现 operator<,operator== (用strcmp模拟),其余均可复用实现

  3.3 流提取(>>)

注意:
 ① cin 无法提取含空格的串,如“abc d”只能提取到 abc(因为空格和换行默认为多个值之间的分隔符),此时要使用 istream类中的函数get代替cin
 ② 流提取具有覆盖效果,此处模拟实现clear进行
优化:
 模拟缓冲区,使用buff数组避免频繁扩容(每127个字符扩一次容)
  ① 每127个字符后添加 ‘/0’(处理刚好为127倍数长度的串)
  ② 循环结束后 i ≠ 0时,添加’/0’(处理不为127倍数长度的串)

4. 传统写法与现代写法

上文模拟实现部分就是传统写法,核心思想为自己动手做,而现代写法主要体现了复用的思想,让别人干活,交换

  4.1 拷贝构造

//现代写法 s2(s1)
string::string(const string& s)
{
	string tmp(s._str); //让构造干活
	swap(tmp); //交换成员
}

在这里插入图片描述

思路:

  1. 复用构造,构造与s1内容一致的tmp
  2. 将s2与s1 交换成员
     ① s2声明后未初始化,指向随机值,将tmp与s2交换类成员,s2得到了想要的拷贝效果
     ② 而tmp为局部变量,出作用域会调用析构函数自动销毁

  4.2 赋值运算符重载

//s1 = s3
	/*V1版本*/
string& string::operator=(const string& s)
{
	if (this != &s)
	{
		//string tmp(s);
		string tmp(s._str);
		swap(tmp);
	}

	return *this;
}
	/*V2 版本(代码量减少,但效率不变)*/
string& string::operator=(string tmp) //调用拷贝构造tmp(s3)
{
	swap(tmp);

	return *this;
}

在这里插入图片描述

思路:

  1. 复用构造 / 拷贝构造,构造与s3内容一致的tmp
  2. 将s1与 tmp 交换成员
     ① tmp与s1交换类成员,s1得到了想要的拷贝效果
     ② 而tmp为局部变量,出作用域会调用析构函数自动销毁

五、扩展阅读

5.1 写时拷贝

引入情景:
 深拷贝效率低,对浅拷贝进行优化处理 使之能使用

浅拷贝问题与解决:

  1. 析构多次(同一块空间,不同的对象)
    => 引用计数:不为1时,计数- -
          为1时,即最后一个对象,此时才释放空间
  2. 一个修改影响另一个
    => 写时拷贝:进行修改的才走深拷贝开辟空间,否则走浅拷贝共用空间(核心:不修改就赚了)

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

注意:下述结构是在32位平台下进行验证,32位平台下指针占4个字节。

  • vs下string的结构
    string总共占28个字节,内部结构稍微复杂一点,先是有一个联合体,联合体用来定义string中字符串的存储空间:
    • 当字符串长度小于16时,使用内部固定的字符数组来存放
    • 当字符串长度大于等于16时,从堆上开辟空间
union _Bxty
{ 	
	value_type _Buf[_BUF_SIZE];
	pointer _Ptr;
	char _Alias[_BUF_SIZE]; 
} _Bx;

这种设计也是有一定道理的,大多数情况下字符串的长度都小于16,那string对象创建好之后,内部已经有了16个字符数组的固定空间,不需要通过堆创建,效率高。
其次:还有一个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类的常用接口,并对其中重点接口进行了模拟实现,以便读者了解其底层逻辑,有利于更好地使用。
尽管文章修正了多次,但由于水平有限,难免有不足甚至错误之处,敬请各位读者来评论区批评指正。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值