• C++——string常用接口模拟实现

    目录

    一. string常用接口补充——to_string和stoi

    二. 深浅拷贝

    1. 浅拷贝

    2. 深拷贝

     三. string模拟实现——传统方法

    四. string模拟实现——现代方法

    五. string模拟实现——其他常用接口

    1. c_str()

    2. 重载[ ]

    3. size()

    4. capacity()

    5. reserve()

    6. insert()插入单个字符

    7. insert()插入字符串

    8. push_back()

    9. append()

    10. 重载+=字符

    11. 重载+=字符串

    12. resize()

    13. erase()

    14. find()查找字符

    15. find()查找字符串

    15. clear()

    16. 迭代器

    17. ==、!=、>=，>，<=，<逻辑操作符的重载

    18. 重载<<

    19. 重载>>

    六. 了解部分——写时拷贝

    一. string常用接口补充——to_string和stoi

    to_string将整形数字和浮点型数字转换为字符串
    stoi将数字字符串转化为整形数字
    1.     //数字转字符串
    2. 	string s1("hello world");
    3. 	int i = 1234567890;
    4. 	string s2 = to_string(i);
    5. 	cout <<  s2 << endl;
    6. 	
    7. 	//字符串转数字
    8. 	string s3("0987654321");
    9. 	int n = stoi(s3);
    10. 	cout << n << endl;

    二. 深浅拷贝

    当我们没有自己实现拷贝构造函数时，使用的是默认的拷贝构造函数。

    1. namespace mystring
    2. {
    3. 	class string
    4. 	{
    5. 	public:
    6. 		string(const char* str = "")
    7. 		{
    8. 			_str = new char[strlen(str + 1)];
    9. 			strcpy(_str, str);
    10. 		}
    11.  
    12. 		//析构函数
    13. 		~string()
    14. 		{
    15. 			if (_str)
    16. 			{
    17. 				delete[]_str;
    18. 			}
    19. 		}
    20.  
    21. 	private:
    22. 		char* _str;//指向字符串
    23. 	};
    24. }
    25.  
    26. // 测试
    27. void test()
    28. {
    29.     String s1("hello");
    30.     String s2(s1);
    31. }

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

    1. 浅拷贝

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

    浅拷贝会出现的问题即多次释放同一块空间。遇到这个问题时，我们需要采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。

    2. 深拷贝

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

     三. string模拟实现——传统方法

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. //string实现
    7. namespace mystring
    8. {
    9. 	class string
    10. 	{
    11. 	public:
    12. 		//构造函数
    13.         //使用缺省值，成为默认构造函数
    14.         //无参构造函数调用，可以使用缺省值，标准库是给的空字符串
    15.         //使用依次初始化的方式不用频繁调用strlen
    16. 		string(const char* str = "")
    17. 			:_size(strlen(str))
    18. 			, _capacity(_size)
    19. 		{
    20. 			_str = new char[_capacity + 1];
    21. 			strcpy(_str, str);
    22. 		}
    23.  
    24. 		//拷贝构造函数，不写该拷贝构造函数则发生拷贝时会是浅拷贝
    25. 		string(const string& s)
    26. 			:_str(new char[s._capacity + 1])
    27. 			, _size(s._size)
    28. 			, _capacity(s._capacity)
    29. 		{
    30. 			strcpy(_str, s._str);
    31. 		}
    32.  
    33.         //重载=
    34. 		string& operator=(const string& s)
    35. 		{
    36. 			//自己给自己赋值不配进来
    37. 			if (_str != s._str)
    38. 			{
    39. 				char* temp = new char[s._capacity + 1];
    40. 				strcpy(temp, s._str);
    41. 				delete[]_str;
    42. 				_str = temp;
    43. 				_size = s._size;
    44. 				_capacity = s._capacity;
    45. 			}
    46.  
    47. 			return *this;
    48. 		}
    49.  
    50. 		//析构函数
    51. 		~string()
    52. 		{
    53.             //防止释放nullptr
    54. 			if (_str)
    55. 			{
    56. 				delete[]_str;
    57. 				_str = nullptr;
    58. 				_size = _capacity = 0;
    59. 			}
    60. 		}
    61. 	private:
    62. 		char* _str;//指向字符串
    63. 		size_t _size;//有效字符个数
    64. 		size_t _capacity;//容量的大小
    65.  
    66.         //声明npos
    67. 		const static size_t npos;
    68. 		//const static size_t npos = -1;不推荐，类里的只是声明，不应该是定义
    69. 	};
    70.  
    71.     //定义npos
    72. 	const size_t string::npos = -1;
    73. }

    注意：构造函数使用缺省值，成为默认构造函数，无参对象可调用，可以使用缺省值，标准库是给的空字符串，使用依次初始化的方式不用频繁调用strlen，_capacity + 1是预留一个'\0'

    四. string模拟实现——现代方法

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. //string实现
    7. namespace mystring
    8. {
    9. 	class string
    10. 	{
    11. 	public:
    12. 		//构造函数
    13.         //使用缺省值，成为默认构造函数
    14.         //无参构造函数调用，可以使用缺省值，标准库是给的空字符串
    15.         //使用依次初始化的方式不用频繁调用strlen
    16. 		string(const char* str = "")
    17. 			:_size(strlen(str))
    18. 			, _capacity(_size)
    19. 		{
    20. 			_str = new char[_capacity + 1];
    21. 			strcpy(_str, str);
    22. 		}
    23.  
    24. 		//交换函数，交换两个对象
    25. 		void swap(string& s)
    26. 		{
    27. 			//std里的swap是浅拷贝
    28. 			std::swap(_str, s._str);
    29. 			std::swap(_size, s._size);
    30. 			std::swap(_capacity, s._capacity);
    31. 		}
    32.  
    33. 		//现代方法的拷贝构造，将s初始化，防止当=里拷贝构造过来的的地址是随机值，然后释放随机值
    34. 		string(const string& s)
    35. 			:_str(nullptr)
    36. 			, _size(0)
    37. 			, _capacity(0)
    38. 		{
    39. 			//借用temp构造完了再给s
    40. 			string temp(s._str);
    41. 			swap(temp);
    42. 		}
    43.  
    44.         //现代方法重载=，s不使用传引用和const，使用传值
    45. 		string& operator=(string s)
    46. 		{
    47. 			//将赋值右边对象拷贝构造到s里，再将s里的和赋值左边的对象交换
    48.             //由s将和赋值左边对象交换过来的释放（即释放左边的对象）
    49. 			swap(s);
    50. 			return *this;
    51. 		}
    52.  
    53. 		//析构函数
    54. 		~string()
    55. 		{
    56. 			if (_str)
    57. 			{
    58. 				delete[]_str;
    59. 				_str = nullptr;
    60. 				_size = _capacity = 0;
    61. 			}
    62. 		}
    63. 	private:
    64. 		char* _str;//指向字符串
    65. 		size_t _size;//有效字符个数
    66. 		size_t _capacity;//容量的大小
    67.  
    68.         //声明npos
    69. 		const static size_t npos;
    70. 		//const static size_t npos = -1;不推荐，类里的只是声明，不应该是定义
    71. 	};
    72.  
    73.     //定义npos
    74. 	const size_t string::npos = -1;
    75. }

    注意：现代方法引进的思想是创建一个中间对象由中间对象去复制需要拷贝的内容，最后再交换给需要的对象。

    现代方法的拷贝构造需要注意要将s对象初始化，防止当=里拷贝构造过来的的地址是随机值，然后释放随机值引起报错。

    现代方法重载=，s对象不使用传引用传参和const修饰，使用传值传参，目的是将赋值右边的对象拷贝构造到临时对象s里（传值传参需要调用拷贝构造函数），再将s里的内容和赋值左边的对象里的内容交换，由s将和赋值左边对象交换过来的内容释放（即释放左边的对象里的内容）。

    交换函数，交换两个对象，使用的是std里的swap交换函数而不是全局的交换函数，因为std里的swap函数是浅拷贝，只是交换内容，减少性能消耗。

    五. string模拟实现——其他常用接口

    1. c_str()

    1. //返回C语言字符串，让const对象和非const对象都可以调用该函数
    2. const char* c_str() const
    3. {
    4.     return _str;
    5. }
    6.  
    7. mystring::string s1("hello world");
    8. cout << s1.c_str() << endl;

    这里使用const修饰的是*this，即让传过来的对象不能被更改，返回const是为了不让对象里的字符串被修改

    2. 重载[ ]

    1. //重载[]
    2. char& operator[](size_t pos)
    3. {
    4. 	//防止越界，小于_size
    5. 	assert(pos < _size);
    6.  
    7. 	return _str[pos];
    8. }
    9.  
    10. //重载[]的const版本，需要注意返回值也需要被const修饰
    11. const char& operator[](size_t pos) const
    12. {
    13. 	assert(pos < _size);
    14.  
    15. 	return _str[pos];
    16. }

    解释：需要重载一个const版本为了让const对象调用，并且返回值是const类型的，防止返回以后的字符还是能被修改

    3. size()

    1. //返回字符串长度，const和普通对象都能调用
    2. size_t size() const
    3. {
    4. 	return _size;
    5. }

    解释：加上const，为了让const对象也能调用

    4. capacity()

    1. //返回字符串空间容量，const和普通对象都能调用
    2. size_t capacity() const
    3. {
    4. 	return _capacity;
    5. }

    解释：加上const，为了让const对象也能调用

    5. reserve()

    1. //扩容函数
    2. void reserve(size_t n)
    3. {
    4. 	//当n大于容量的时候扩容
    5. 	if (n > _capacity)
    6. 	{
    7. 		char* temp = new char[n + 1];
    8. 		//这种复制如果一直不断插入'\0'会出现问题，除非第一次扩的空间足够大
    9. 		//事实上，一般也不会不断插入'\0'
    10. 		strcpy(temp, _str);
    11. 		delete[]_str;
    12. 		_str = temp;
    13.  
    14. 		_capacity = n;
    15. 	}
    16. }

    注意：不能直接先释放_str，如果是自己扩容会出现问题

    6. insert()插入单个字符

    1. //insert插入字符
    2. string& insert(size_t pos, char ch)
    3. {
    4. 	//越界处理
    5. 	assert(pos <= _size);
    6.  
    7. 	if (_size + 1 > _capacity)
    8.     {
    9. 		reserve(_size + 1);
    10. 	}
    11.  
    12. 	//这样写由于无符号整数的原因，会死循环
    13. 	/*size_t end = _size;
    14. 	while (end >= pos)
    15. 	{
    16. 		_str[end + 1] = _str[end];
    17. 		--end;
    18. 	}*/
    19.  
    20. 	//注意由于_size是\0，所以这里其实\0也会一起往后移动，不需要自己添加
    21. 	size_t end = _size + 1;
    22. 	while (end > pos)
    23. 	{
    24. 		_str[end] = _str[end - 1];
    25. 		--end;
    26. 	}
    27. 	_str[pos] = ch;
    28. 	++_size;
    29.  
    30. 	return *this;
    31. }

    注意：要注意被注释的写法，会死循环

    7. insert()插入字符串

    1. //insert插入字符串
    2. string& insert(size_t pos, const char* str)
    3. {
    4. 	//判断合法性
    5. 	assert(pos <= _size);
    6.  
    7. 	size_t length = strlen(str);
    8. 	size_t end = _size + length;
    9.  
    10. 	//判断扩容
    11. 	if (end > _capacity)
    12. 	{
    13. 		reserve(end);
    14. 	}
    15.  
    16. 	//当end在pos+length位置时还需要移
    17. 	while (end > pos + length - 1)
    18. 	{
    19. 		_str[end] = _str[end - length];
    20. 		--end;
    21. 	}
    22.  
    23. 	//从pos位置开始复制
    24. 	strncpy(_str + pos, str, length);
    25. 	_size += length;
    26.  
    27. 	return *this;
    28. }

    注意：循环位置的判断，我们要写的是循环继续的条件，当end大于pos+length-1时，说明还有字符未拷贝到后面，当end到了pos+length-1时，正好在拷贝完的下一个位置，即中断循环，还需要注意拷贝开始的位置

    8. push_back()

    1. //实现push_back，插入单个字符函数
    2. void push_back(char ch)
    3. {
    4. 	扩容
    5. 	//if (_size == _capacity)
    6. 	//{
    7. 	//	//reserve(_capacity * 2);//当对象是无参构造时_capacity=0
    8. 	//	reserve(_capacity == 0 ? 4 : _capacity * 2);
    9. 	//}
    10.  
    11. 	//_str[_size] = ch;
    12. 	//++_size;
    13. 	最后需加上'\0'
    14. 	//_str[_size] = '\0';
    15.  
    16. 	//复用insert
    17. 	insert(_size, ch);
    18. }

    解释：这里可以复用insert插入单个字符，或者是自己写，自己写不复用需要注意不能盲目乘以2，不然_capacity是0时就会出现传给reserve是0

    9. append()

    1. //实现append，尾部插入字符串
    2. void append(const char* str)
    3. {
    4. 	str长度
    5. 	//int length = strlen(str) + _size;
    6. 	length大于容量需要扩容
    7. 	//if (length > _capacity)
    8. 	//{
    9. 	//	reserve(length);
    10. 	//}
    11.  
    12. 	//strcpy(_str + _size, str);
    13. 	//_size = length;
    14.  
    15. 	//复用insert
    16. 	insert(_size, str);
    17. }

    解释：同样是可以复用insert，如果自己写需要注意拷贝开始的位置

    10. 重载+=字符

    1. //+=字符重载
    2. string& operator+=(char ch)
    3. {
    4.     push_back(ch);
    5.  
    6. 	return *this;
    7. }

    解释：复用一下push_back即可

    11. 重载+=字符串

    1. //+=字符串重载
    2. string& operator+=(const char* str)
    3. {
    4. 	append(str);
    5.  
    6. 	return *this;
    7. }

    解释：复用一下append即可

    12. resize()

    1. //扩空间+初始化
    2. //删除部分数据，保留前n个
    3. void resize(size_t n, char ch = '\0')
    4. {
    5. 	//当n小于有效数据个数时，减少有效数据个数
    6. 	if (n < _size)
    7. 	{
    8. 		_str[n] = ch;
    9. 		_size = n;
    10. 	}
    11. 	//当n大于容量时需要扩容并用ch初始化
    12. 	else
    13. 	{
    14. 		reserve(n);
    15. 		for (size_t i = _size; i < n; ++i)
    16. 		{
    17. 			_str[i] = ch;
    18. 		}
    19. 		_size = n;
    20. 		_str[_size] = '\0';
    21. 	}
    22. }

    注意：resize扩空间是需要初始化多余的空间的，resize只会缩小有效字符个数_size，不会缩小容量，也就是说_capacity是不会被改变的

    13. erase()

    1. //删除pos位置的字符或者是字符串
    2. string& erase(size_t pos, size_t len = npos)
    3. {
    4. 	//判断越界情况
    5. 	assert(pos < _size);
    6.  
    7. 	//当长度大于字符串长度即全部删除
    8. 	if (len == npos || len + pos >= _size)
    9. 	{
    10. 		_str[pos] = '\0';
    11. 		_size = pos;
    12. 	}
    13. 	//长度小于字符串
    14. 	else
    15. 	{
    16. 		size_t begin = pos + len;
    17. 		while (begin <= _size)
    18. 		{
    19. 			_str[begin - len] = _str[begin];
    20. 			++begin;
    21. 		}
    22. 		_size = pos;
    23. 	}
    24.  
    25. 	return *this;
    26. }

    解释：分类讨论删除的情况，确定要删除的位置

    14. find()查找字符

    1. //查找字符，pos为开始找的位置，如果没有提供，则默认从0位置处开始寻找
    2. size_t find(char ch, size_t pos = 0)
    3. {
    4. 	for (; pos < _size; ++pos)
    5. 	{
    6. 		if (_str[pos] == ch)
    7. 			return pos;
    8. 	}
    9.  
    10. 	//找不到需要返回npos
    11. 	return npos;
    12. }

    注意：需要注意的是找不到需要返回npos，否则返回下标，npos在上面已经声明和定义

    15. find()查找字符串

    1. //查找字符串，pos为开始找的位置，如果没有提供，则默认从0位置处开始寻找，找到则返回第一个字符的下标
    2. size_t find(const char* str, size_t pos = 0)
    3. {
    4. 	char* p = strstr(_str + pos, str);
    5. 	if (p == nullptr)
    6. 	{
    7. 		return npos;
    8. 	}
    9.  
    10. 	return p - _str;
    11. }

    解释：直接套用strstr库函数查找，找不到strstr返回nullptr，需要我们另外判断并返回pos，利用指针减指针返回两个指针之间的距离即下标

    15. clear()

    1. //清理对象
    2. void clear()
    3. {
    4. 	_str[0] = '\0';
    5. 	_size = 0;
    6. }

    解释：直接使用\0来清理

    16. 迭代器

    1. //迭代器，提供const防止数据被篡改
    2. typedef char* iterator;
    3. typedef const char* const_iterator;
    4.  
    5. const_iterator begin() const
    6. {
    7. 	return _str;
    8. }
    9.  
    10. const_iterator end() const
    11. {
    12. 	return _str + _size;
    13. }
    14.  
    15. iterator begin()
    16. {
    17. 	return _str;
    18. }
    19.  
    20. iterator end()
    21. {
    22. 	return _str + _size;
    23. }

    解释：string的迭代器就是字符指针typedef后来的，提供const版本是为了const对象也可以使用迭代器，需要注意的是begin和end不能更改，因为使用范围for遍历时是替换成迭代器的，但是范围for里的begin和end是固定这样的，不能更改为其他函数名，甚至大写也不行，否则会报错

    17. ==、!=、>=，>，<=，<逻辑操作符的重载

    1. //操作符重载，使用c_str()函数不需要访问私有成员，可以不使用友元
    2. bool operator<(const string& s1, const string& s2)
    3. {
    4. 	return strcmp(s1.c_str(), s2.c_str()) < 0;
    5. }
    6.  
    7. bool operator==(const string& s1, const string& s2)
    8. {
    9. 	return strcmp(s1.c_str(), s2.c_str()) == 0;
    10. }
    11.  
    12. bool operator<=(const string& s1, const string& s2)
    13. {
    14. 	return s1 < s2 || s1 == s2;
    15. }
    16.  
    17. bool operator!=(const string& s1, const string& s2)
    18. {
    19. 	return !(s1 == s2);
    20. }
    21.  
    22. bool operator>(const string& s1, const string& s2)
    23. {
    24. 	return !(s1 <= s2);
    25. }
    26.  
    27. bool operator>=(const string& s1, const string& s2)
    28. {
    29. 	return !(s1 < s2);
    30. }

    解释：这些重载在类外，由于使用了c_str()函数，所以不需要访问私有成员，也就不用使用友元

    18. 重载<<

    1. //重载<<
    2. ostream& operator<<(ostream& out, const string& s)
    3. {
    4. 	//不使用下面这种方法主要是因为某些特殊情况下会出问题，如需要打印\0
    5. 	/*out << s.c_str();
    6. 	return out;*/
    7.  
    8. 	for (auto ch : s)
    9. 	{
    10. 		out << ch;
    11. 	}
    12.  
    13. 	return out;
    14. }

    解释：重载在类外，虽然实现了c_str()，但是在vs2019使用c_str()会出现不可见字符（\0）无空位的情况，2013中可见，所以采用范围for的方式打印

    19. 重载>>

    1. //重载>>
    2. istream& operator>>(istream& in, string& s)
    3. {
    4. 	//当s有初始值时清理s
    5. 	s.clear();
    6.  
    7. 	//使用istream的get函数一个一个的获取字符
    8. 	char ch = in.get();
    9.  
    10. 	//先存储到字符数组里
    11. 	char buff[128] = {'\0'};
    12.  
    13. 	//当字符数组里被存满且未满足条件时，就放到s里并清空数组
    14. 	size_t i = 0;
    15. 	while (ch != ' ' && ch != '\n')
    16. 	{
    17. 		buff[i++] = ch;
    18. 		//预留\0，字符串结尾标志
    19. 		if (i == 127)
    20. 		{
    21. 			//满了放入s里
    22. 			s += buff;
    23. 			//清空并用\0初始化
    24. 			memset(buff, '\0', 127);
    25. 			//清零重来
    26. 			i = 0;
    27. 		}
    28.  
    29. 		ch = in.get();
    30. 	}
    31.  
    32. 	//将输入的字符放入s里
    33. 	s += buff;
    34.  
    35. 	return in;
    36. }

    解释：重载在类外，注意需要先清理一下对象，使用先存入数组的方式是为了减少某些情况下不断扩容的带来的性能消耗

    六. 了解部分——写时拷贝

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

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

    由于使用了引用计数，这就就解决了析构的问题，但是一个对象被修改了是会影响其他对象的。

    其实，核心理念就是：延迟拷贝，如果没有写，那就不会拷贝，就赚到了。

    想了解更多看这里——写时拷贝。

    还有写时拷贝读取时的缺陷——写时拷贝在读取时的缺陷。

    更多的string看这里——面试中string的一种正确写法。

    吐槽向——STL中的string怎么啦？

  • 相关阅读:
    解决VSCode使用SSH远程连接时无法指定用户名的问题
    RxJava操作符
    EasyNLP 中文文图生成模型带你秒变艺术家
    基于Java+控制台实现教材管理系统
    2022百度之星初赛第三场-三个因子
    charles抓包电脑微信小程序
    南京邮电大学电工电子基础B实验六（组合逻辑电路）
    Pytest模式执行python脚本不生成allure测试报告
    git提交代码到远程仓库
    Calendar 求取指定时间 下周一 下一月1号 下一年1月1号 下一季度首月1号
  • 原文地址：https://blog.csdn.net/Britney_dark/article/details/126177430