【C++】string类的模拟实现

于 2021-07-29 12:00:39 发布
阅读量382 收藏
点赞数
分类专栏： C++ 文章标签： string stl C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/116305800
版权

文章目录

一. 简单string类设计

主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数等资源管理功能。

1. private成员

就是一个C语言中的字符串指针

class string
{
public:

private:
	char* _str;
};

2. 构造函数

我们设计一个全缺省的默认构造函数，如果不传参时就默认存储\0,就是空串

class string
{
public:
	//构造函数（错误写法）
	string(char* str = '\0')
	{
		_str = str;
	}

private:
	char* _str;
};

上面的那个写法其实是错误的，当我们显示地给string对象初始值（字符串）时，这个字符串是存储在代码段的常量，只读不可写。不能进行修改操作的话这个string对象也就没意义了。

在这里插入图片描述

既然不能传存在代码段的常量字符串，那么我们传存储在栈上的字符串行不行？也不行，栈上的字符串是存储在字符数组里的，我们虽然可以修改但是不能扩容，因为数组定义出来时空间就是定死的，这样不方便我们对字符串进行资源管理。

在这里插入图片描述

既想要修改字符串内容又想随时扩容，那么把string对象的值放在堆上是最合适的。此时存储在堆空间上的字符串既可以像栈上的字符串一样修改，又可以随时通过new[ ]来开辟你想要大小的空间。

class string
	{
	public:
		//构造函数（正确写法）
		string(const char* str = '\0')//const char* str=""  两种写法一样
		{
			// 1.让_str指向我们在堆上开辟的空间（多开一个为了存储\0）
			_str = new char [strlen(str) + 1];

			// 2.把 str 内容拷贝到 _str（也就是把代码段的内容（str）拷贝到堆空间上（_str））
			strcpy(_str, str);
		}

	private:
		char* _str;
	};

3. 析构函数

使用delete[ ]释放我们开辟的空间，再把_str置为nullptr（防止野指针）

class string
	{
	public:
	    //析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

	private:
		char* _str;
	};

4. 拷贝构造和赋值重载

这里一定要显示定义拷贝构造和赋值重载，如果用默认的会造成浅拷贝问题（多次释放同一块空间）

4.1 什么是浅拷贝？

默认的拷贝构造和赋值重载都是通过浅拷贝实现的。浅拷贝就是一个字节一个字节的拷，浅拷贝也叫值拷贝

在这里插入图片描述

4.2 浅拷贝带来的问题

在这里插入图片描述

4.3 深拷贝完成拷贝构造和赋值重载

既然是指向同一块空间带来的问题，那我们就重新开辟一块同样大小的空间，利用strcpy把另一块空间的内容拷贝到新开辟空间上，这就是深拷贝。

  • 浅拷贝：空间相同，内容相同
  • 深拷贝：空间不同，内容相同

拷贝构造

传统写法：

class string
	{
	public:
		//拷贝构造
		string(const string& s)
		{
			// 1.在_str指向一块新开辟的同样大小的空间（加一个是为了存储\0）
			_str = new char[strlen(_str) + 1];
			// 2.拷贝str空间的内容到_str指向的空间里
			strcpy(_str, s._str);
		}

	private:
		char* _str;
	};

现代写法（更加简洁）：

class string
	{
	public:
		string(const string& s)
		{
			string tmp(s._str);
			//这里的swap是c++提供的
			//交换_str和tmp.str指向的空间
			//出了函数tmp生命周期结束，自动调用析构函数释放tmp的空间（也就是原来s的空间）
			swap(_str, tmp._str);
		}

	private:
		char* _str;
	};

赋值重载
赋值重载的两个对象都已经初始化过了，所以在把右值拷贝给左值前要先把左值的旧空间释放，在让它指向新空间

传统写法：

class string
	{
	public:
		//赋值重载
		string& operator=(const string& s)
		{
		    if(this!=&s)
		    {
			   // 1.在_str指向一块新开辟的同样大小的空间（加一个是为了存储\0）
			   char* newstr = new char[strlen(s._str) + 1];
			   // 2.拷贝str空间的内容到newstr指向的空间里
			   strcpy(newstr, s._str);
			   // 3.释放旧的空间
			   delete[] _str;
			   // 4.让_str指向新开辟并且已经拷贝了值的空间
			   _str = newstr;
			   //返回
			   return *this
			}
		}

	private:
		char* _str;
	};

现代写法：

class string
	{
	public:
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);//拷贝构造s
				swap(_str, tmp._str);
			}
			return *this;
		}

	private:
		char* _str;
	};

赋值重载的几点说明：

  • 返回值：为了支持连等，返回值为string又因为出了这个函数之后*this（也就是左值）依然存在所以返回左值的引用（少一次拷贝构造）。
  • 参数值：对于右值我们只是读它的值用来拷贝给左值，并不修改它的内容，所以加上const修饰

二. string类的模拟实现

private成员

除了字符数组（_str）外还加了 _size（记录当前有效字符个数），_capacity（记录可以存储多少个有效字符）和static常量npos(npos就是size_t类型的-1)

class string
{
public:

private:
	char* _str;
	size_t _size;
	size_t _capacity;
	static const size_t npos;
};

接下来我们介绍几个较复杂的接口

1. string类对象容量操作接口

1.1 reserve

原型：void reserve (size_t n = 0);
作用：给字符串对象扩容，若n小于等于当前容量（_capacity）啥事没有；n大于当前容量就扩容

void reserve(size_t n=0)
		{
			if (n > _capacity)
			{
				char* newstr = new char[n+1];// 1.开新空间
				strcpy(newstr, _str);        // 2.拷贝旧空间
				delete[] _str;               // 3.释放旧空间
				_str = newstr;               // 4.指向新空间
				_capacity = n;               // 5.更新容量
			}
		}
1.2 resize

原型：void resize (size_t n, char c=’\0’);
作用：将有效字符的个数改成n个，如果大于原size多出的有效空间用字符c填充，如果没有传字符c，那就默认是字符’ \0 ';如果小于原size就会截断多出来的有效字符。

void resize(size_t n, char c = '\0')
		{
			if (n > _size)
			{
				//检查是否需要扩容
				if (n > _capacity)
				{
					reserve(n);
				}
				memset(_str + _size, c, n - _size);
				_size = n;
				_str[_size] = '\0';
			}
			else if(n<_size)
			{
				_size = n;
				_str[_size] = '\0';
			}
		}

		//简化后可以这样写
		void resize(size_t n, char c = '\0')
		{
			if (n>_size)
			{
				if (n > _capacity)
				{
					reserve(n);
				}
				memset(_str + _size, c, n - _size);
			}
			_size = n;
			_str[_size] = '\0';
		}

如果要求的有效字符个数大于原来的size那么我们用memset来设置后面多出的有效空间，要注意的是memset是一个字节一个字节地拷贝，一般只在设置字符的时候才会用这个。

下面举个例子来说明这个问题：我们要把10容量的整形数组arr内容用memset设置为3
在这里插入图片描述
通过计算器也可以佐证我们的结果
在这里插入图片描述
按照一个字节一个字节来设置的就只适用于给字符数组来设置字符，因为一个字符的大小就是一个字节
在这里插入图片描述

2. string类对象字符串操作接口

2.1 c_str

原型：const char* c_str() const;
作用：返回C格式字符串，只可读不可写

就是直接返回成员变量_str，它的类型是char*

const char* c_str() const
{
	return _str;
}

C格式字符串和string对象还是不同的，C格式字符串看’ \0 ‘，用cout输出时遇到’ \0 ‘就结束了；而string对象看的是它的有效字符个数（也就是_size），不管中间有没有’ \0 ’

2.2 substr

原型：string substr (size_t pos = 0, size_t len = npos) const;
作用：在str中从pos下标开始，截取n个字符，然后将其返回

string substr(size_t pos = 0, size_t len = npos) const
		{
			//既然是子串，那下标必须合法
			assert(pos < _size);
			if (len > _size)
			{
				len = _size-pos;
			}
			char* tmp = new char[len + 1];// 1.开新空间（多开一个为了存储\0）
			strncpy(tmp, _str + pos, len);// 2.拷贝子串到新空间
			tmp[len] = '\0';              // 3.处理末尾的\0
			string s_tmp(tmp);            // 4.利用前面开的子串空间拷贝构造一个string对象
			delete[] tmp;                 // 5.释放前面开的新空间
			return s_tmp;                 // 6.返回拷贝构造的string类对象
		}

3. string类对象修改操作接口

3.1 insert

原型：string& insert (size_t pos, const char* s);
作用：在pos位置插入一个字符串

string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			// 1.判断容量是否足够，不够的话需要增容
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			// 2.保证空间足够了，就开始挪动数据（一个字符一个字符的挪）
			size_t end = _size;
			while ((int)pos <= (int)end)
			{
				_str[end + len] = _str[end];
				end--;
			}
			// 3.挪好之后，开始放数据
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

关于insert的几点说明
在这里插入图片描述

3.2 erase

原型：string& erase (size_t pos = 0, size_t len = npos);
作用：删除 pos 下标后的 len 长度字符串

string& erase(size_t pos = 0, size_t len = npos)
		{
			assert(pos < _size);
			// 1.如果要求的长度大于等于后面的有效字符的长度，就是删除pos后面的所有有效字符
			if (len >= _size - pos)
			{
				len = _size - pos;
				resize(pos);
			}
			else// 2.删除的是中间一段的话，那就直接把前后拼接起来
			{
				strncpy(_str + pos, _str + pos + len, _size - pos - len + 1);
				_size -= len;
			}
			return *this;
		}

关于erase的几点说明
在这里插入图片描述

4. string类的非成员函数

4.1 operator<<

原型：ostream& operator<< (ostream& out, const string& s);
作用：string类的<<运算符重载

ostream& operator<<(ostream& out, const string& s)
	{
		int len = s.size();
		// 把字符串的字符一个一个的输出，共输出size个
		for (size_t i = 0; i < s.size(); i++)
		{
			out << s[i]; 
		}
		// 最后还要返回out，为了支持连续的<<操作
		return out;
	}

在这里插入图片描述

4.2 operator>>

原型：istream& operator>> (istream& , string& s);
作用：重载string类的<<运算符

该运算符读取和C语言里的scanf一样，在读取字符串时不能读取到空格和回车，都是输入回车时算输入完毕。

istream& operator>>(istream& in, string& s)
	{
		while (1)
		{
			char c = in.get();// 从缓冲区接收数据，一个字符一个字符的接收

			//如果遇到空格或者回车算接收完毕
			if (c == ' ' || c == '\n')
			{
				break;
			}
			else// 否则把字符尾插到对象
			{
				s += c;
			}
		}
		return in;
	}
4.3 getline

原型：istream& getline (istream& is, string& str);
作用：string类对象接收一行的数据（空格也可以接收）

相当于C语言的gets()，可以接收一行的数据

istream& getline(istream& in, string& s)
	{
		while (1)
		{
			char c = in.get();
			if (c == '\n')// 从缓冲区接收数据，遇到回车才停止
			{
				break;
			}
			else
			{
				s += c;
			}
		}
		return in;
	}

5. string类的iterator

对于string类而言，它的typedef就是char*(iterator要在类内的pubulic内声明)，既然是char*那么就可以像C语言里面的指针一样使用了。

class string
{
public:
    //string类的iterator
	typedef char* iterator;

private:
	char* _str;
	size_t _size;
	size_t _capacity;
	static const size_t npos;
};

我们可以用iterator来遍历string类对象

void test_string()
	{
		string s("hello");
		my_string::string::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
	}

其实auto也是的底层也是迭代器，auto最终会被编译器转化成迭代器
在这里插入图片描述

帝国无伤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
21天学通C++之--String类的设计实现
qq_24052051的博客
04-12 1324
在c++中，自定义构造函数，运算符重载，析构函数，自定义函数，内存分配构成了这门语言知识的半壁江山，这里带给大家我的c++中string类的实现及要求 题目描述 模拟标准库字符串类实现你自己的字符串类。该类需具有构造，字符串连接、取子串和复制、赋值、输出等功能。要求使用动态分配存储字符串内容。不可使用STL string类 输入描述 测试程序有4个字符串，每个样例前两行含长
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
C++ string Class 使用
红羊家园
03-10 4576
C++ string class The C++ Standard Template Library (STL) contains a string class that is used in several computer science classes. In order to use the string class you should include the following s
模拟实现 string类
weixin_39381806的博客
07-02 186
模拟实现string类
模拟实现string类
CodingStart
07-01 481
string类的模拟实现
C++中string的模拟实现
09-01
k() 函数是将字符添加到字符串末尾。在 C++ 的标准库中，`std::string` ...在实际编程中，标准库提供的 `std::string` 类通常更为高效和安全，但在学习和理解 C++ 的面向对象编程时，这样的模拟实现是非常有价值的。
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
String类的模拟实现
小东的博客
07-27 547
  C++最重要的模块之一就是string类，很多人在这一节点被劝退，在本篇文章中小编将逐个为你们突破，分模块将string中几个重要的接口实现，如果对string类有困难的读者们，强烈推荐仔细阅读本文章。   本章没有废话，全是干货，请读者们仔细阅读！！！！！！ 1、string类的四个默认成员函数   一个类有6个默认成员函数，其中取地址重载相关的成员函数这里不做讲解，我们实现剩下的四个默认成员函数：   A：构造函数–主要完成初始化工作   B：拷贝构造函数–同类对象的初始化   C：赋值重载函数–
string类模拟实现
M_jianjianjiao
11-25 387
string类部分函数模拟实现 对于一些常用的string类的函数进行模拟实现，通过对一些函数的模拟是实现了解，其底层的实现原理，加深对于string 类中的函数的理解 构造函数 String(const char* str="")//使用缺省参数 27 :_str(new char[strlen(str)+1]) //预留一个位置放‘\...
String 类的模拟实现
Hello_Sue的博客
07-02 454
String 类的模拟实现 一 .构造函数时使用初始化列表的优点
c++string类的模拟实现
最新发布
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值