C++ string类的模拟实现

转x33g5p2x  于2022-02-14 转载在 C/C++  
字(5.7k)|赞(0)|评价(0)|浏览(528)

前言：模拟实现string类之前先思考下需要实现哪些接口功能呢？

1.string类的迭代器。

2.string类的构造函数、析构函数、拷贝构造函数、赋值运算符重载。

3.管理字符串的数组，可以增删查改，具体包括reverse、resize、push_back、append、insert、erase、find、clear、getline接口的实现。

4.[]、+=、<、<=、==、>、>=、！=、<<、>>运算符重载。

提示：重点是string类的四个默认成员函数以及增删查改的实现。

string类的结构定义

  1. class string
  2. {
  3. public:
  5. private:
  6. 	char* _str;
  8. 	size_t _size;
  9. 	size_t _capacity;
  11. 	static const size_t npos;
  12. };

补充下npos是什么，简单理解就是无符号整型中的-1

1.string类迭代器的实现

这里string类的迭代器完全可以简单理解成指针实现、包括vector也是类似，但是到了后边的容器会有所不同。

这里只需要注意一下end( )代表什么：

  1. class string
  2. {
  3. public:
  4.     typedef char* iterator;
  5. 		typedef const char* const_iterator;
  7. 		iterator begin()
  8. 		{
  9. 			return _str;
  10. 		}
  12. 		const_iterator begin() const
  13. 		{
  14. 			return _str;
  15. 		}
  17. 		iterator end()
  18. 		{
  19. 			return _str + _size;
  20. 		}
  22. 		const_iterator end() const
  23. 		{
  24. 			return _str + _size;
  25. 		}
  26.         
  27. };

2.string类的构造、析构、拷贝构造、赋值运算符重载

2.1 string类的构造函数

  1. string(const char* str = "")
  2. {
  3. 	_size = strlen(str);
  4. 	_capacity = _size;
  5. 	_str = new char[_capacity + 1];//给_str一个strlen(s)+1长度的空间
  7. 	strcpy(_str, str);//拷贝
  8. }

2.2 string类的析构函数

  1. ~string()
  2. {
  3. 	delete[] _str;
  4. 	_str = nullptr;
  5. 	_size = 0;
  6. 	_capacity = 0;
  7. }

2.3 string类的拷贝构造函数

传统和现代两种写法

  1. // s1.swap(s2);
  2. void swap(string& s)
  3. {
  4.     //交换_s和tmp._s,就相当于给this->_s开辟了一块空间,当拷贝函数结束,tmp就会被自动释放
  5. 	::swap(_str, s._str);
  6. 	::swap(_size, s._size);
  7. 	::swap(_capacity, s._capacity);
  8. }
  10. //传统写法
  11. //s2(s1)
  12. string(const string& s)
  13. 	:_str(new char[strlen(s._str)+1])
  14. {
  15. 	strcpy(_str, s._str);
  16. }
  18. // s2(s1)  现代写法
  19. string(const string& s)
  20. 	:_str(nullptr)//必须置空,因为_str开始是个随机数,交换给tmp._str后,释放会引起问题
  21. 	, _size(0)
  22. 	, _capacity(0)
  23. {
  24. 	string tmp(s._str);//直接利用构造函数,给tmp对象开辟了一块空间
  26. 	//this->swap(tmp);
  27. 	swap(tmp);
  28. }

2.4 string类的赋值运算符重载

传统和现代两种写法

  1. // s1 = s3 传统写法
  2. string& operator=(const string& s)
  3. {
  4. 	if (this != &s) // s1 = s1
  5. 	{
  6. 		delete[] _str;
  7. 		_str = new char[strlen(s._str) + 1];
  8. 		strcpy(_str, s._str);
  9. 	}
  11. 	return *this;
  12. }
  14. // s1 = s3 现代写法
  15. string& operator=(string s)
  16. {
  17. 	swap(s);//这个swap是咱们自己写的哦
  19. 	return *this;
  20. }

3.管理字符串的数组，可以增删查改

具体包括reverse( )、resize( )、push_back( )、append( )、insert( )、erase( )、find( )、clear( )、getline( )、size( )、c_str( )接口的实现。

3.1 reverse( ) 接口实现

  1. // 开空间，扩展capacity
  2. void reserve(size_t n)
  3. {
  4. 	if (n > _capacity)
  5. 	{
  6. 		char* tmp = new char[n + 1];//注意哦~,这里必须要多开一个空间存储\0
  7. 		strncpy(tmp, _str, _size + 1);//多开的那个空间存储位置
  8. 		delete[] _str;
  10. 		_str = tmp;
  11. 		_capacity = n;
  12. 	}
  13. }

3.2 resize( ) 接口实现

resize( ) 分为三种情况

  • 当n小于size,则size等于n.
  • 当n>size但是小于capacity时,size仍等于n,但是这个时候即使你传入另一个参数ch,也没有用
  • 当n大于size时候,会增容,然后多出的空间会用ch初始化,ch如果不传,就是\0,最后size等于n,
  1. // 开空间+初始化，扩展capacity 并且初始化空间。size也要动
  2. void resize(size_t n, char val = '\0')
  3. {
  4. 	if (n < _size)
  5. 	{
  6. 		_size = n;
  7. 		_str[_size] = '\0';
  8. 	}
  9. 	else
  10. 	{
  11. 		if (n > _capacity)
  12. 		{
  13. 			reserve(n);
  14. 		}
  16. 		for (size_t i = _size; i < n; ++i)
  17. 		{
  18. 			_str[i] = val;
  19. 		}
  20. 		_str[n] = '\0';
  21. 		_size = n;
  22. 	}
  23. }

3.3 push_back( ) 接口实现

push_back( ) 针对的是字符

  1. void push_back(char ch)
  2. {
  3. 	if (_size == _capacity)
  4. 	{
  5.         //这一步是为了防止_capacity如果为0,开不了空间
  6. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
  7. 	}
  8. 	_str[_size] = ch;
  9. 	_str[_size + 1] = '\0';//给字符串末尾加\0
  10. 	++_size;
  12. 	//insert(_size, ch);  //或者直接调用insert()
  13. }

3.4 append( ) 接口实现

append( )针对的是字符串

  1. void append(const char* str)
  2. {
  3. 	/*size_t len = _size + strlen(str);
  4. 	if (len > _capacity)
  5. 	{
  6. 		reserve(len);
  7. 	}
  9. 	strcpy(_str + _size, str);
  10. 	_size = len;*/
  12. 	insert(_size, str);
  13. }

3.5 insert( ) 接口实现

包括字符和字符串的插入，需要写两个版本。

  1. //插入字符
  2. string& insert(size_t pos, char ch)
  3. {
  4. 	assert(pos <= _size);
  5. 	if (_size == _capacity)
  6. 	{
  7. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
  8. 	}
  9. 	// 类型强制转换成int，使用size_t的话，就永远走不出循环了（因为无符号整型的-1）
  10. 	/*int end = _size;
  11. 	while (end >= (int)pos)
  12. 	{
  13. 		_str[end + 1] = _str[end];
  14. 		--end;
  15. 	}*/
  17. 	char* end = _str + _size;
  18. 	while (end >= _str + pos)
  19. 	{
  20. 		*(end + 1) = *end;
  21. 		--end;
  22. 	}
  24. 	_str[pos] = ch;
  25. 	_size++;
  27. 	return *this;
  28. }
  30. //在pos位置之前插入字符串
  31. string& insert(size_t pos, const char* str)
  32. {
  33. 	assert(pos <= _size);
  34. 	size_t len = strlen(str);
  35. 	if (_size + len > _capacity)
  36. 	{
  37. 		reserve(_size + len);
  38. 	}
  40. 	// 挪动数据
  41. 	char* end = _str + _size;
  42. 	while (end >= _str + pos)
  43. 	{
  44. 		*(end + len) = *end;
  45. 		--end;
  46. 	}
  48. 	strncpy(_str + pos, str, len);
  49. 	_size += len;
  51. 	return *this;
  52. }

3.6 erase( ) 接口实现

从pos位置开始删除,len个,如果len不写,末尾删除pos后的全部

  1. string& erase(size_t pos, size_t len = npos)
  2. {
  3. 	assert(pos < _size);
  4. 	size_t leftLen = _size - pos;
  5. 	// 1、剩余的字符长度小于要删的长度  （后面全部删完）
  6. 	// 2、剩余的字符长度大于要删的长度
  7. 	if (len >= leftLen)
  8. 	{
  9. 		_str[pos] = '\0';
  10. 		_size = pos;
  11. 	}
  12. 	else
  13. 	{
  14. 		strcpy(_str + pos, _str + pos + len);
  15. 		_size -= len;
  16. 	}
  18. 	return *this;
  19. }

3.7 find( ) 接口实现

包括字符和字符串的查找，需要写两个版本。

  1. size_t find(char ch, size_t pos = 0)
  2. {
  3. 	assert(pos < _size);
  5. 	for (size_t i = pos; i < _size; ++i)
  6. 	{
  7. 		if (_str[i] == ch)
  8. 		{
  9. 			return i;
  10. 		}
  11. 	}
  13. 	return npos;
  14. }
  16. size_t find(const char* str, size_t pos = 0)
  17. {
  18. 	assert(pos < _size);
  20. 	const char* ret = strstr(_str + pos, str);
  21. 	if (ret)
  22. 	{
  23. 		return ret - _str;
  24. 	}
  25. 	else
  26. 	{
  27. 		return npos;
  28. 	}
  29. }

3.8 clear( ) 接口实现

  1. void clear()
  2. {
  3. 	_size = 0;
  4. 	_str[0] = '\0';
  5. }

3.9 getline( ) 接口实现

  1. istream& getline(istream& in, string& s)
  2. {
  3. 	s.clear();
  5. 	char ch;
  6. 	ch = in.get();
  7. 	while (ch != '\n')
  8. 	{
  9. 		s += ch;
  10. 		ch = in.get();
  11. 	}
  13. 	return in;
  14. }

3.10 size( ) 接口实现

  1. size_t size() const
  2. {
  3. 	return _size;
  4. }

3.11 c_str( ) 接口实现

  1. const char* c_str() const
  2. {
  3. 	return _str;
  4. }

4.[]、+=、<、<=、==、>、>=、！=、<<、>>运算符重载。

4.1 [] 运算符重载

在c++中,string的operator[]有两个重载,分别是:

  • char& operator[] (size_t pos); //支持读和写
  • const char& operator[] (size_t pos) const; //只支持读
  1. // 读
  2. const char& operator[](size_t i) const
  3. {
  4. 	assert(i < _size);
  6. 	return _str[i];
  7. }
  9. // 可读，可写
  10. char& operator[](size_t i)
  11. {
  12. 	assert(i < _size);
  14. 	return _str[i];
  15. }

4.2 == 运算符重载

  1. inline bool operator==(const string& s1, const string& s2)
  2. {
  3. 	return strcmp(s1.c_str(), s2.c_str()) == 0;
  4. }

4.3 += 运算符重载

  1. // s1 += 'x'  针对字符
  2. string& operator+=(char ch)
  3. {
  4. 	push_back(ch);
  5. 	return *this;
  6. }
  8. // s1 += "xxxxx" 针对字符串
  9. string& operator+=(const char* str)
  10. {
  11. 	append(str);
  12. 	return *this;
  13. }

4.4 < 运算符重载

  1. inline bool operator<(const string& s1, const string& s2)
  2. {
  3. 	return strcmp(s1.c_str(), s2.c_str()) < 0;
  4. }

4.4 <= 运算符重载

  1. inline bool operator<=(const string& s1, const string& s2)
  2. {
  3. 	return s1 < s2 || s1 == s2;
  4. }

4.5 > 运算符重载

  1. inline bool operator>(const string& s1, const string& s2)
  2. {
  3. 	return !(s1 <= s2);
  4. }

4.6 >= 运算符重载

  1. inline bool operator>=(const string& s1, const string& s2)
  2. {
  3. 	return !(s1 < s2);
  4. }

4.7 != 运算符重载

  1. inline bool operator!=(const string& s1, const string& s2)
  2. {
  3. 	return !(s1 == s2);
  4. }

4.8 << 运算符重载

  1. ostream& operator<<(ostream& out, const string& s)
  2. {
  3. 	for (auto ch : s)
  4. 	{
  5. 		out << ch;
  6. 	}
  8. 	return out;
  9. }

4.9 >> 运算符重载

  1. istream& operator>>(istream& in, string& s)
  2. {
  3. 	s.clear();
  5. 	char ch;
  6. 	ch = in.get();
  7. 	while (ch != ' ' && ch != '\n')
  8. 	{
  9. 		s += ch;
  10. 		ch = in.get();
  11. 	}
  13. 	return in;
  14. }

5.代码仓库

源码链接

小结一下：

感谢您的阅读！！！如果内容对你有帮助的话，记得给我三连（点赞、收藏、关注）——做个手有余香的人。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_48953972/article/details/122908123

内容来源于网络，如有侵权，请联系作者删除！

c++后端开发语言

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com