• C++ 之 string类的模拟实现

    这学习我有三不学

    昨天不学，因为昨天是个过去

    明天不学，因为明天还是个未知数

    今天不学，因为我们要活在当下，我就是玩嘿嘿~

    –❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀-正文开始-❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–

    目录

    一、string类的模拟实现

    1.成员函数(Member functions)

    1.1 构造函数(constructor)

    1.2 析构函数(destructor)

    1.3 赋值拷贝函数(operator=)

    2.迭代器(iterators)

    3.容量(Capacity)

    4.元素访问(Element access)

    5.调节器(Modifiers)

    6.字符操作(String operation)

    7.成员常量(Member constant)npos实现

    8.非成员函数重载(Non-member function overload)

    二、完结撒❀

    前言：

    模拟string类的实现对于我们学习认识string类会有更加深刻的理解，还没学过string类的老铁建议可以先看学习一下我的上一篇博客讲解：C++ 之 string类 详细讲解，再来进行模拟实现。

    一、string类的模拟实现

    在上篇博客中讲解了string类的常用接口，这篇博客带大家模拟实现一下string类的一些常用接口。

    string类查阅文档

    我们根据上面文档所规划的接口分类为大家进行部分模拟实现，大家可以先简单看一下上面文档。

    1.成员函数(Member functions)

    1.1 构造函数(constructor)

    ● 无参构造函数 string() 实现：

    1. string()
    2. 	//:_str(nullptr)
    3. 	:_str(new char[1])//不能赋空指针，因为直接c_str会出错
    4. 	, _size(0)
    5. 	, _capacity(0)
    6. {
    7. 	_str[0] = '\0';
    8. }

    ● 有参(字符串)构造函数 string(const char* str = "") 实现：

    1. //string(const char* str = nullptr)错
    2. //string(const char* str = '\0')错
    3. string(const char* str = "")//常量字符串默认结尾含有\0
    4. //该构造函数可以替代上面无参构造函数
    5. 	:_size(strlen(str))
    6. {
    7. 	_capacity = _size;
    8. 	_str = new char[_capacity + 1];
    9. 	strcpy(_str, str);
    10. }

    ● 拷贝构造函数 string (const string& s) 实现：
     

    1. //s2(s1)
    2. string (const string& s)
    3. {
    4. 	_str = new char[s._capacity+1];//完成深拷贝，+1 存放\0使用
    5. 	strcpy(_str, s._str);
    6. 	_size = s._size;
    7. 	_capacity = s._capacity;
    8. }

    1.2 析构函数(destructor)

    ● ~string()实现：

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

    1.3 赋值拷贝函数(operator=)

    ● operator=实现：

    1. 	//s2 = s1
    2. 	string& operator=(const string& s)
    3. 	{
    4. 		char* tmp = new char[s._capacity + 1];//多开辟的1个空间用来存储\0
    5. 		strcpy(tmp, s._str);
    6. 		delete[] _str;
    7. 		_str = tmp;
    8. 		_size = s._size;
    9. 		_capacity = s._capacity;
    10.  
    11. 		return *this;//支持连续赋值
    12. 	}

    2.迭代器(iterators)

    ● begin实现：

    在string类中迭代器中begin表示的就是字符串的首地址的指针，但并不是所有迭代器都是由指针来实现的。

    这里使用迭代器的对象有两种，一种是const修饰的，一种是const没有修饰的，所以begin实现应有const修饰，和const不修饰两种：

    1. typedef char* iterator;
    2. typedef const char* const_iterator;
    3.  
    4. iterator begin()
    5. {
    6. 	return _str;
    7. }
    8.  
    9. const_iterator begin() const
    10. {
    11. 	return _str;
    12. }

    ● end实现：

    同理，end实现也一样：

    1. typedef char* iterator;
    2. typedef const char* const_iterator;
    3.  
    4. iterator end()
    5. {
    6. 	return _str + _size;
    7. }
    8.  
    9. const_iterator end() const
    10. {
    11. 	return _str + _size;
    12. }

    这里可以再说一下，范围for的实现也是基于迭代器begin和end所实现的，大家可以在汇编代码中就可以看到。

    而对于const修饰的对象和const没有修饰的对象分别对应使用的范围for其内部实现也是const修饰的begin，end和const没有修饰的begin，end两种范围for。

    3.容量(Capacity)

    ● size实现：

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

    ● capacity实现：

    1. size_t capacity() const
    2. {
    3. 	return _capacity;
    4. }

    ● resize实现：
    由于resize函数的实现可能需要对数组进行扩容，所以我们先实现一下reserve函数：

    1. void reserve(size_t n)
    2. {
    3. 	if (n > _capacity)
    4. 	{
    5. 		char* tmp = new char[n+1];//多开1个位置给\0
    6. 		strcpy(tmp, _str);
    7. 		delete[] _str;//!!!
    8. 		_str = tmp;
    9.  
    10. 		_capacity = n;
    11. 	}
    12. }

    注意：reserve只有在n大于当前有效空间是才会进行开辟，当n小于当前有效空间不会进行任何操作。

    resize实现：

    1. void resize(size n,const char* c)
    2. {
    3.     if(n>_size)
    4.     {
    5.         reserve(n);
    6.         for(size i=size; i
    7.         {
    8.             _str[i] = c;
    9.         }
    10.         _str[n] = '\0';
    11.         _size = n;
    12.     }
    13.     else
    14.     {
    15.         _str[n] = '\0'; 
    16.         _size = n;
    17.     }
    18. }

    ● clear实现：

    注意：clear只是清楚当前所存数据，而不是销毁空间

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

    4.元素访问(Element access)

    ● operator[]实现：

    operator[]的实现功能就是访问string类里面字符串的字符所以实现并不复杂：
     

    1. char& operator[](size_t pos)
    2. {
    3. 	assert(pos < _size);
    4.  
    5. 	return _str[pos];
    6. }
    7.  
    8. const char& operator[](size_t pos) const
    9. {
    10. 	assert(pos < _size);
    11.  
    12. 	return _str[pos];
    13. }

    5.调节器(Modifiers)

    ● insert实现：

    插入字符或字符串那么肯定会涉及到空间不够是否需要扩容的问题，解决了之后剩下的就是将插入位置之后的字符串向后移动插入字符或字符串大小的位置，为要插入的字符或字符串流出插入空间，之后再将字符或字符串插入即可：

    1. void insert(size_t pos, char ch)
    2. {
    3. 	assert(pos <= _size);
    4.  
    5. 	if (_size == _capacity)
    6. 	{
    7. 		//扩容。。。reserve
    8. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    9. 	}
    10.  
    11. 	//后移字符串方案1
    12. 	//int end = _size;
    13. 	//while (end >= (int)pos)//!!!一个运算符两边操作数类型不同的时候发生类型提升（范围小的像范围大的提升 这里有符号向无符号提升）
    14. 	//{
    15. 	//	_str[end + 1] = _str[end];
    16. 	//	--end;
    17. 	//}
    18.  
    19. 	//后移字符串方案2
    20. 	size_t end = _size + 1;
    21. 	while (end > pos)
    22. 	{
    23. 		_str[end] = _str[end - 1];
    24. 		--end;
    25. 	}
    26. 	_str[pos] = ch;
    27. 	_size++;
    28. }
    29.  
    30. void insert(size_t pos, const char* str)
    31. {
    32. 	assert(pos <= _size);
    33.  
    34. 	size_t len = strlen(str);
    35. 	if (_size + len > _capacity)
    36. 	{
    37. 		reserve(_size + len);
    38. 	}
    39.  
    40. 	size_t end = _size + len;
    41. 	while (pos < end - len + 1)
    42. 	{
    43. 		_str[end] = _str[end - len];
    44. 		--end;
    45. 	}
    46.  
    47. 	strncpy(_str + pos, str, len);
    48. 	_size += len;
    49. }

    ● append实现：
    既然已经实现了insert，那么我们直接赋用insert实现append，push_back,operator+=即可：

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

    ● push_back实现：

    1. void push_back(const char ch)
    2. {
    3. 	//if (_size == _capacity)
    4. 	//{
    5. 	//	//扩容。。。reserve
    6. 	//	reserve(_capacity == 0 ? 4 : _capacity * 2);
    7. 	//}
    8.  
    9. 	//_str[_size] = ch;
    10. 	//_str[_size + 1] = '\0';
    11. 	//++_size;
    12.  
    13. 	insert(_size, ch);
    14. }

    ● operator+=实现：
     

    1. string& operator+=(const char ch)
    2. {
    3. 	push_back(ch);
    4. 	return *this;
    5. }
    6.  
    7. string& operator+=(const char* str)
    8. {
    9. 	append(str);
    10. 	return *this;
    11. }

    ● erase实现：

    当len要清除的字符长度大于等于总字符长度减去pos起始位置时就要将pos起始位置后面的字符全都清除，即_str[pos] = '\0'即可。

    1. 	void erase(size_t pos = 0, size_t len = npos)
    2. 	{
    3. 		assert(pos < _size);
    4. 		
    5. 			if (pos == npos || pos >= _size - len)
    6. 			{
    7. 				_str[pos] = '\0';
    8. 				_size = pos;
    9. 			}
    10. 			else
    11. 			{
    12. 				strcpy(_str + pos, _str + pos + len);
    13. 				_size -= len;
    14. 			}
    15. 	}

    6.字符操作(String operation)

    ● c_str实现：

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

    ● find实现：

    1. size_t find(const char c, size_t pos = 0) const
    2. {
    3. 	assert(pos < _size);
    4.  
    5. 	//从pos位置开始遍历字符串
    6. 	for (size_t i = pos; i < _size; i++)
    7. 	{
    8. 		if (_str[i] == c)
    9. 		{
    10. 			return i;
    11. 		}
    12. 	}
    13. 	return npos;
    14. }
    15.  
    16. size_t find(const char* sub, size_t pos = 0) const
    17. {
    18. 	assert(pos < _size);
    19.  
    20. 	const char* p = strstr(_str+pos, sub);
    21. 	if (p)
    22. 	{
    23. 		return p - _str;//指针-指针为两指针之间的距离
    24. 	}
    25. 	return npos;
    26. }

    ● substr实现：


    与erase分析相似，当要截取的len长度的字符大于等于总字符长度_size减起始位置pos时，就要将pos后面的字符全部截取进行返回：

    1. 	string substr(size_t pos = 0, size_t len = npos) const
    2. 	{
    3. 		string sub;
    4. 		if (len >= _size - pos)
    5. 		{
    6. 			for (size_t i = pos; i < _size; i++)
    7. 			{
    8. 				sub += _str[i];
    9. 			}
    10. 		}
    11. 		else
    12. 		{
    13. 			for (size_t i = pos; i < pos + len; i++)
    14. 			{
    15. 				sub += _str[i];
    16. 			}
    17. 		}
    18. 		return sub;
    19. 	}

    7.成员常量(Member constant)npos实现：

    在标准库中，npos为静态全局变量，在npos文档中就有说明，其值应为size_t类型的-1。

    1. private:
    2. 	char* _str = nullptr;
    3. 	size_t _size = 0;
    4. 	size_t _capacity = 0;
    5.  
    6. 	public:
    7. 		static size_t npos;//类内声明
    8. };
    9.  
    10. size_t string::npos = -1;//类外定义

    8.非成员函数重载(Non-member function overload)

    ● swap实现：


    在C++库中是有swap函数的，我们可以直接调用使用，但是对于自定义类型来说就比如string类，其直接调用库中的swap函数进行交换的话会调用3次拷贝构造+1次析构(库中的swap实现方式是创建一个新的临时变量tmp进行两个值的交换)，这样消耗会很大，所以对于自定义类型我们不推荐直接调用库里面的swap函数。

    那么我们该如何实现swap函数呢？我们可以直接对自定义类型里面的内置成员变量进行交换即可满足两者自定义类型的交换，将swap函数定义为非成员函数是因为要满足swap(s1,s2);交换的格式。

    内部成员函数：

    1. 	void swap(string& s)
    2. 	{
    3. 		std::swap(_str, s._str);
    4. 		std::swap(_size, s._size);
    5. 		std::swap(_capacity, s._capacity);
    6. 	}

    非成员函数(全局函数)：

    1. void swap(string& s1, string& s2)
    2. {
    3. 	s1.swap(s2);//直接调用成员函数即可
    4. }

    ● operator<<实现：

    1. ostream& operator<<(ostream& out, const string& s)
    2. {
    3. 	for (auto ch : s)
    4. 	{
    5. 		out << ch;
    6. 	}
    7. 	return out;//实现连续打印
    8. }

    ● operator>>实现：

    1. istream& operator>>(istream& in, string& s)
    2. {
    3. 	s.clear();//输入变量值之前需要将变量原先所存的值给清除
    4. 	char ch;
    5. 	ch = in.get();//可以获取空格' ',cin不支持获取空格
    6.  
    7. 	while (ch != ' ' && ch != '\n')
    8. 	{
    9. 		s += ch;
    10. 		ch = in.get();
    11. 	}
    12.  
    13. 	return in;//实现连续赋值
    14. }

    ● getline实现：

    1. istream& getline(istream& in, string& s)
    2. {
    3. 	s.clear();
    4.  
    5. 	char c;
    6. 	c = in.get();
    7. 	//栈区开辟空间，栈区开辟空间比堆区开辟空间高
    8. 	char ch[128];//提高效率
    9. 	size_t i = 0;
    10.  
    11. 	while (c != '\n')
    12. 	{
    13. 		ch[i++] = c;
    14.  
    15. 		if (i == 127)
    16. 		{
    17. 			ch[127] = '\0';
    18. 			s += ch;
    19. 			i = 0;
    20. 		}
    21.         c = in.get();
    22. 	}
    23.  
    24. 	if (i > 0)
    25. 	{
    26. 		ch[i] = '\0';
    27. 		s += ch;
    28. 	}
    29. 	return in;
    30. }

    上面所实现的都是string类的常用的一些接口，其他一些没有实现的大家感兴趣的话可以查阅其他资料自行模拟实现一下

    二、完结撒❀

    如果以上内容对你有帮助不妨点赞支持一下，以后还会分享更多编程知识，我们一起进步。
    最后我想讲的是，据说点赞的都能找到漂亮女朋友❤

  • 相关阅读:
    浅谈IDEA的目录
    8.2 JUC - 4.Semaphore
    软件安全性测试工具
    vue重修004【下部】
    多线程能有事务吗？
    Vue - 虚拟DOM的简单理解
    在Docker中安装redis
    学习操作系统之分时系统+时间片
    LVS负载均衡群集之原理叙述
    Spring通过注解管理Bean对象
  • 原文地址：https://blog.csdn.net/foodsx/article/details/138196414