string的模拟实现

于 2024-08-07 14:32:58 发布
阅读量474 收藏 15
点赞数 11
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82669797/article/details/140987328
版权
P. S.：以下代码均在VS2019环境下测试，不代表所有编译器均可通过。
P. S.：测试代码均未展示头文件stdio.h的声明，使用时请自行添加。

  

在这里插入图片描述

                                           博主主页：Yan. yan.
                                              C语言专栏
                                            数据结构专栏
                                         力扣牛客经典题目专栏
                                                     C++专栏

文章目录

一、string的成员变量

在模拟string的时候，成员变量如下：

private:
		size_t _size;
		size_t _capacity;
		char* _str;

二、string的默认成员函数

1、构造函数

1.1、默认构造（无参构造）

构造是不进行初始化，默认为空字符串。

string()
	:_str(new char[1])
	, _size(0)
	, _capacity(0)
{
	_str[0] = '\0';
}

1.2、普通构造

  • 思路：
  • 1、开辟一块新空间。
  • 2、把原数据拷贝的新空间。
  • 3、释放新空间。
  • 4、_str指向新空间。
//无参和全缺省合并
string(const char* str = "")
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[_capacity + 1]; //多开一个空间给/0
			//strcpy(_str, str);  strcpy默认只拷贝到'\0'终止，但有些情况是要拷贝完全，包括'\0'
			memcpy(_str, str, _size + 1); //\0也需要拷贝
		}

解释：

  • 新申请的空间往往会多申请一个，用来存放 ’ \0 ’
  • 使用memcpy而不是使用strcpy的原因：
    如果使用strcpy，这样的情况会出现问题：
    “hello\0xxxxx”
    strcpy默认只拷贝到’\0’,memcpy按照字节数拷贝，包括’\0’也会拷贝

1.3、无参构造和全缺省构造合并

合并如下：

string(const char* str = "")
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[_capacity + 1]; //多开一个空间给/0
			//strcpy(_str, str);  strcpy默认只拷贝到'\0'终止，但有些情况是要拷贝完全，包括'\0'
			memcpy(_str, str, _size + 1); //\0也需要拷贝
		}

如果没有传参，默认是空字符串，如果传参，则使用该参数。

深拷贝和浅拷贝

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

一句话来说：一块空间由多个对象共同管理。

  深拷贝：每个对象有自己独立的空间，不会和其他对象共享，他们之间互不影响。

2、拷贝构造

  拷贝构造是深拷贝，所以我们要实现深拷贝。

  • 思路：
  • 开辟一个和原字符串一样大小的空间。
  • 将原字符串的内容拷贝到新空间。
string(const string& s)
		{
			_str = new char[s._capacity + 1];
			memcpy(_str, s._str, _size + 1);
			_size = s._size;
			_capacity = s._capacity;
		}

3、赋值运算符重载

  赋值：例如s1= s2。

  • 思路：
  • 先用s拷贝构造一个临时对象。
  • 释放原str空间。
  • 将str指针指向临时对象，此时str就是s的拷贝了。
  • tmp临时对象在结束调用该函数之后编译器会自动调用析构函数进行销毁
  • 返回*this
string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				memcpy(tmp, s._str, _size+1);
				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}
		}

4、析构函数

~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
				_size = _capacity = 0;
			}
		}

三、[]的下标访问和iterator迭代器

1、operator[]重载

普通[]

char& operator[](size_t pos)
		{
			//_size 的位置是'\0'
			assert(pos < _size);
			return _str[pos];
		}

const修饰的[]

const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

2、begin迭代器

typedef char* iterator;
typedef const char* const_iterator;

iterator begin()
{
	return _str;
}

const_iterator begin() const
{
	return _str;
}

3、end迭代器

iterator end()
{
	return _str + _size;
}

const_iterator end() const
{
	return _str + _size;
}

四、对容器空间操作

1、size()

返回_size即可

size_t size() const
		{
			return _size;
		}

2、capacity（）

size_t capacity() const
		{
			return _capacity;
		}

3、empty

判空

bool empty() const
		{
			return _size == 0;
		}

4、reserve——重要

reserve函数第对对象进行扩容操作的。

  • 思路：
  • 如果需要扩容的空间小于原空间，则不会进行缩容操作
  • 否则，进行扩容操作。
  • 先申请一块新的空间，然后将原空间的数据拷贝到新空间
  • 再释放原空间，将原空间的指针指向新空间。
  • 更新capacity即可。
void reserve(size_t n)
		{
			//不仅仅append，push_back会用到，其他地方也可能用到reserve，不会缩容
			//如果是缩容的情况的话，不允许发生
			if (n > _capacity)
			{
				char* tmp = new char[n + 1]; //留给'\0'
				//strcpy(tmp, _str);
				memcpy(tmp, _str, n + 1);

				delete[] _str;//如果不销毁，就会出现内存泄露。
				_str = tmp;
				_capacity = n; // 不能等于 n + 1，容量不包含'\0'
			}

注意：我们需要用memcpy拷贝更合理，因为实际情况会出现诸如"hello\0world"的情况

5、resize——重要

resize是对对象进行扩容，然后同时将size提升到指定的数据大小的。
库的实现是：将对象调整空间到指定大小，如果比原容量大，且不给指定需要填充的字符，多出来的空间默认填充为’\0’。

  • 思路：
  • 如果要调整的大小小于或者等于当前容量，则不会进行缩容，只会让size调整，默认用’\0’填充size位置即可
  • 如果要调整的大小大于当前容量，则调用reserve函数进行扩容，如果不给指定的字符，则默认将后面的空间填充成’\0’即可。
void resize(size_t n, char c = '\0')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				//先扩容
				reserve(n);
				//将后面的空间全部填充成c
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = c;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

五、增删查改工作

1、push_back（）

push_back在库中的实现是，向字符串末尾插入一个字符。

  • 思路：
  • 首先需要检查容量，如果容量不足则需要扩容。
  • 再将最后一个字符插入到’\0’位置
  • size++，然后将size位置放置’\0’
void push_back(char c)
{
	//满了，要扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);//不需要再+1,reserve的扩容机制是会自己多给几个空间
	}
	//在'\0'后面尾插
	_str[_size] = c;

	++_size;
	//记得要在后面+'\0'
	_str[_size] = '\0';
}

2、append

append函数是在字符串末尾追加一个字符串。

  • 思路：
  • 检查容量
  • 在字符串末尾开始拷贝要追加的字符串即可。
  • 需要注意的问题是，检查容量时，扩容不能扩2倍，因为可能追加的字符串比2倍的容量还长，具体请看代码。
void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		//追加一个字符串，扩二倍不一定够，所以至少扩容到_size + len;
		reserve(_size + len); //不需要再+1,reserve的扩容机制是会自己多给几个空间。
	}

	//strcpy(_str + _size, str);
	memcpy(_str + _size, str, len + 1);//memcpy默认会拷贝'\0'

	_size += len;
	_str[_size] = '\0';
}

3、operator+=

对于这个运算符重载，有两种情况

  • +=一个字符
  • +=字符串
    我们直接复用push_back函数和append函数即可。
string& operator+=(char c)
{
	push_back(c);
	return *this;
}
string& operator+=(const char* str)
{
	append(str);
	return *this;
}

4、insert（）

在pos位置插入n个字符c。

void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	//扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}

	_str[pos] = ch;
	_size++;
}

在pos位置插入一个字符串

void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				end--;
			}

			strncpy(_str + pos, str, len);
			_size += len;
		}

5、erase()

删除pos位置开始的len个字符。
如果不给参数，默认从0开始删除所有字符。
注意：npos表示无穷大

  • 思路：
  • 情况一：如果要删除所有元素，直接将size置为0，然后将size位置设置成’\0’即可。
  • 情况二：在pos位置删除len个字符
  • 将pos位置开始的len个字符从前往后挪动即可，（'\0’也需要挪动）
void erase(size_t pos, size_t len = npos)
		{
			assert(pos <= _size);
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t begin = pos + len;
				while (begin <= _size)
				{
					_str[begin - len] = _str[begin];
					begin++;
				}
				_size -= len;
			}
		}

6、find（）

版本1：在字符串中找出第一次出现的字符c，返回该位置下标。

size_t find(char ch, size_t pos = 0)
		{
			for (size_t i = 0; i < _size; i++)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}
			return npos;
		}

版本2：在字符串中找出一个指定的子串，返回第一次出现的位置。

size_t find(const char* sub, size_t pos = 0)
		{
			const char* p = strstr(_str + pos, sub);
			if (p)
			{
				return p - _str;
			}
			else
			{
				return npos;
			}
		}

7、substr()

该函数的功能是：从pos位置开始，返回len个字符组成的字符串。
相当于返回一个特定的子串。

string substr(size_t pos, size_t len = npos)
		{
			string s;
			size_t end = pos + len;
			if (len == npos || pos + len >= _size)
			{
				len = _size - len;
				end = _size;
			}

			s.reserve(len);
			for (size_t i = pos; i < pos + len; i++)
			{
				s += _str[i];
			}

			return s;
		}

六、比较运算符重载

1、operator<

bool operator<(const string& s) const
		{
			return strcmp(_str, s._str) < 0;
		}

2、operator==

  • 思路：
  • 只要两个字符串相等，则它们的size必定相等。
  • 用memcmp比较即可。
bool operator==(const string& s) const
		{
			if (_size != s._size)
				return false;

			return strcmp(_str, s._str) == 0;
		}

3、operator<=,>,>=,!=

bool operator<=(const string& s) const
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s) const
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s) const
		{
			return !(*this < s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}

七、流插入和流提取

注意：流插入和流提取均为全局函数，不是类对象的成员函数。

1、流插入<<（流插入和c_str()的区别）

库的流插入的实现是，完整地打印出字符串的所有内容，包括’\0’

而c_str()函数是返回字符串的首地址，那么就可以通过首地址打印，然而会遇到’\0’停止。

ostream& operator<<(ostream& out, const string& s)
{
	for (size_t i = 0; i < s.size(); i++)
	{
		out << s[i];
	}
	/*for (auto ch : s)
		out << ch;*/

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

2、流提取

  • 库的实现是：
  • 遇到在遇到字符之前遇到的空格’ ‘和斜杠n换行符’\n’，都会刷新缓冲区，会重新进行读取。
  • 所以可以在这里使用get函数进行缓冲区的刷新，get函数会一直读取，遇到空格或者换行不会停止。
  • 在遇到字符之后，如果再遇到空格’ ‘或者斜杠n换行符’\n’，默认是多字符串的输入。
  • 使用buf数组来减少扩容的代价。
istream& operator>>(istream& in, string& s)
	{
		s.clear();

		char ch;
		//in >> ch;
		ch = in.get();
		s.reserve(128);

		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			//in >> ch;
			ch = in.get();
		}

		return in;
	}
Yan. yan.好好学习
关注
  • 11
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
C++中string的模拟实现
09-01
在 C++ 的标准库中，`std::string` 提供了 `push_back()` 成员函数来实现这个功能，但在我们的模拟实现中，我们需要自己创建这个功能： ```cpp void String::Push_Back(char c) { if (_sz == _capacity) { // 如果...
【C++】string模拟实现
2303_79329831的博客
05-18 1858
本篇博客主要内容：实现string类的基本功能。string使用很快就讲完了，但是光会用string还不够，在面试中，面试官总喜欢让我们自己来模拟实现string类，包括string类的构造、拷贝构造、赋值运算符重载以及析构函数等等内容。所以，我认为string类的自实现还是有必要讲一下的。本篇博客主要介绍了string类常用接口的实现，包括默认成员函数，迭代器，字符和字符串的插入删除等等内容。♥STLC++
c++ - string模拟实现
2302_79539362的博客
05-13 613
string模拟实现
C++ [STL之string模拟实现]
ARMCSKGT的博客
05-19 5598
前面我们介绍了STL容器string的部分接口使用，有了string使我们对字符串的操作如鱼得水，其实string不止于使用方便，其实现也有许多我们值得学习的地方，本节将为您介绍string常用接口的代码实现！
⚡【C++要笑着学】(17) 模拟实现 string：深浅拷贝 | string 模拟实现 | 传统写法与现代写法
有道无术, 术尚可求。有术无道, 止于术。
05-07 4343
本章将正式介绍深浅拷贝，在模拟实现 string 的同时带着去理解深浅拷贝。我们模拟实现 string类不是为了造更好的轮子，而是为了去学习它，理解它的本质！你自己造一次，心里会更清楚，也有利于加深对 string 的理解。...
『C++成长记』string模拟实现
小王又困了的博客
07-08 2535
本篇我们将为大家介绍string常用接口的模拟实现。
【C++初阶】string模拟实现
weixin_74967884的博客
05-13 1971
本章节详细的讲解了string模拟实现。
【C++】STL-string模拟实现
chuxinchangcun的博客
12-22 6070
public:string是一个管理字符数组的类,要求这个字符数组结尾用\0标识1.拷贝构造和赋值重载实现深拷贝2.增删查找的相关接口(跟顺序表类似)3.重载了一些常见的运算符 如: > < >> 加const2.只写接口函数 ->不加const3.可读可写接口函数 ->分为加const版本和不加const版本。
【C++】string的模拟实现
学了就忘是正常现象
11-16 2676
C++中string类的模拟实现。
模拟实现string类
weixin_58867976的博客
03-10 4065
目录 前言 一、初始准备 二、迭代器 三、构造函数 四、赋值运算符重载 五、插入字符及字符串 六、查找字符及字符串 七、删除字符或字符串 八、重载关系运算符 九、重载+=运算符 十、析构函数 十一、重载输入输出运算符 十二、全部代码 前言 由于string类的接口函数很多，所以这里只实现常用的接口函数 部分很简单的接口函数，都放在代码段里了 一、初始准备 引用头文件 引用string的头文件，是为了后面写接口函数，需要调用字符串函数，比如strstr，strcpy等
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
String各个接口模拟实现
08-27
String各个接口模拟实现
string类的模拟实现
04-29
string类的模拟实现
C++ STL copy_backward, move_backward 用法
08-04 221
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
C++ - 函数重载
jiaowenjie的专栏
08-06 156
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++初学者指南-5.标准库(第二部分)--数值运算算法
最新发布
silencestarsky的博客
08-06 605
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
C++ STL copy, move 用法
08-04 237
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
js string format 模拟实现c++
08-09
在 JavaScript 中实现类似于 C 语言中的字符串格式化功能，可以采用一些方法。首先，可以定义一个名为`format`的函数，该函数可以接受格式化字符串作为第一个参数，以及任意数量的参数来填充该格式化字符串。下面是一种实现方式： ```javascript function format(str, ...params) { return str.replace(/\{(\d+)\}/g, function(_, index) { return params[index]; }); } ``` 这个函数中，我们使用了正则表达式来匹配格式化字符串中的`{}`占位符。其中`\{(\d+)\}`表示一个由花括号包围的数字，并且通过`g`标志启用全局匹配模式。在替换的回调函数中，我们将占位符中的数字作为索引查找对应的参数值，并将其返回。 接下来，我们可以调用这个`format`函数来进行字符串格式化，例如： ```javascript const name = 'John'; const age = 30; const formattedString = format('My name is {0} and I am {1} years old.', name, age); console.log(formattedString); // 输出: "My name is John and I am 30 years old." ``` 在这个示例中，我们传递了两个参数`name`和`age`，分别填充了格式化字符串中的`{0}`和`{1}`。最后，我们将得到一个包含填充内容的格式化字符串。 使用这种方式实现的字符串格式化功能可以方便地应用于 JavaScript 中的字符串拼接和格式化操作，更加灵活和易用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值