• C++语法（9）---- 模拟string

    目录

    1.构造函数

    1.实现传入字符数组

    2.实现传入字符串

    3.=的字符重载

    2.析构函数

    3.扩容函数

    4.字符串中尾插元素

    1.加入一个字符

    2.加入一串字符

    5.resize函数

    6.c_str返回string类中数组的地址

    7.迭代器

    8.指定位置插入

    1.插入一个字符

    2.插入字符串

    9.删除字符串

    10.find函数

    1.找一个字符

    2.找一串字符

    11.清空函数和判空函数

    1.清空函数

    2.判空函数

    12.逻辑比较运算符重载

    13.流提取和流插入

    1.流插入

    2. 流提取

    模拟string类时，我们需要有些成员变量，因为string是关于字符串的类，所以存储内容使用字符的数组来存储；有存储空间需要被记录，现在记录的空间也要被记录，这两个都用无符号整型存储。

    1.构造函数

    这里我们只实现传入字符数组和字符串的构造函数。

    1.实现传入字符数组

    在传入字符时，可以进行对传入的数组指针做缺省，但是要注意，为了字符串通过缺省得到空字符，不能直接传入空指针实现，因为strlen不能通过空指针得到0，所以传入空字符串即可。注意，capacity中我在设计中没有把‘/0’算入容量中，所以扩容时我们要对数组中加一个空间存储‘\0’，但是不把其加入到capacity。

    1. string(const char* str="")
    2. {
    3. 	size = _capacity = strlen(str); 
    4.     //注意_capacity存储的是有效字符，未把/0考虑进去，所以，后续扩容需要注意在扩容基础上加1
    5. 	_str = new char[_capacity + 1];
    6. 	strcpy(_str, str);
    7. }

    2.实现传入字符串

    利用strcpy进行复制数组里的内容，要注意必须有该构造函数，如果没有这个构造函数会出现一个问题：浅拷贝导致的最后析构函数调用两次。

    1. string(const string& s)
    2. {
    3. 	_size = _capacity = s._size;
    4. 	_str = new char[_capacity + 1];
    5. 	strcpy(_str, s._str);
    6. }

     利用构造函数写拷贝构造 

    1. string(const string& s)
    2. 	:_str(nullptr)
    3. 	, _size(0)
    4. 	, _capacity(0)
    5. {
    6. 	string tmp(s._str);       //tmp最后指向未知的地方，如果之前的*this未定义，所以需要上面的初始化列表
    7. 	swap(_str, tmp._str);
    8. 	swap(_size, tmp._size);
    9. 	swap(_capacity, tmp._capacity);
    10. }

     

    3.=的字符重载

    需要传入的this中的内容与要等于的数组不是同一个，所以判断不等于后开辟空间strcpy每一个数组的元素。

    1. string& operator=(const string& s)
    2. {
    3. 	if (this != &s)
    4. 		{
    5. 			char* tmp = new char[s._capacity + 1];
    6. 			strcpy(tmp, s._str);
    7. 			delete[] _str;
    8.  
    9. 			_size = s._size;
    10. 			_capacity = s._capacity;
    11. 		}
    12. 	return *this;
    13. }

      利用构造函数写拷贝构造 

    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. }
    7.  
    8. string& operator=(string s)
    9. {
    10. 	if (this != &s)
    11. 	{
    12. 		/*char* tmp = new char[s._capacity + 1];
    13. 		strcpy(tmp, s._str);
    14. 		delete[] _str;
    16. 		_size = s._size;
    17. 		_capacity = s._capacity;*/
    18. 		swap(s);
    19. 	}
    20. 	return *this;
    21. }

    []的运算符重载：是为了让string类也像数组一样被访问所设计的；而string类的设计是通过数组存储的，所以返回的类型使用char类型即可，访问到数组的哪个位置就传入哪个位置的指针。设计两个函数重载的函数，因为该函数调用有需要可读可写的，有点只需要读的。

    那么，如何判断一个函数是否需要加const修饰呢？1.如果这个函数实现后需要对数据进行读的，那么加const即可；2.如果是需要对数据可修改的话，那么就不需要const修饰；3.那么如果该函数调用有需要可读可写的也有只需要可读的，需要写两个进行函数重载即可。

    1. char& operator[](size_t pos)
    2. {
    3. 	return _str[pos];
    4. }
    5.  
    6. char& operator[](size_t pos) const
    7. {
    8. 	return _str[pos];
    9. }

    2.析构函数

    注意释放new开辟的空间需要加方括号，毕竟不是开辟一个单一的空间。将指针指向空指针

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

    3.扩容函数

    设计容量时，我们判断传入的要求容量与目前有的容量对比，如果要求的容量小就不改变内存大小了；如果大于，则扩容到要求的大小，并且需要扩容多一位存储‘\0’。

    1. void reserve(size_t capacity)
    2. {
    3. 	if (capacity > _capacity)
    4. 	{
    5. 		char* tmp = new char[capacity + 1];
    6. 		strcpy(tmp, _str);
    7. 		delete[] _str;
    8. 		_str = tmp;
    9. 		_capacity = capacity;
    10. 	}
    11. }

    4.字符串中尾插元素

    1.加入一个字符

    因为只是插入一个元素，所以不需要考虑扩容多少的问题，同一把空间放大两倍即可。最后把已存入的大小加一，在数组后面加‘\0’作为判断结束标志。

    1. void push_back(char c)
    2. {
    3. 	if (_size == _capacity)
    4. 	{
    5. 		reserve(2 * _capacity);
    6. 	}
    7. 	_str[_size] = c;
    8. 	_str[_size + 1] = '\0';
    9. 	_size++;
    10. }

    +=的运算符重载实现依靠尾插函数实现，最后返回*this指针，函数的返回值为string类的引用以便于加快效率，省去拷贝构造临时变量的时间。

    1. string& operator+=(char c)
    2. {
    3. 	push_back(c);
    4. 	return *this;
    5. }

    2.加入一串字符

    需要注意，上面加入一个字符我们扩容直接通过放大原有空间两倍的方式进行解决；但是这里的问题是，我们不知道加入的字符串有多大，以至于如果我们盲目的扩大已有容量两倍会出现：已存大小字符串加上需要存储字符串的总和大于扩大两倍的容量空间。这样的实现是片面的

    所以我们先记录下需要扩容的具体大小记为n。如果n小于已有的容量，直接加就可以了；如果大于的情况，我们要扩容，我是将空间扩大到1.5倍的n，这样既不会频繁的扩容导致时间效率降低也不会使得空间开辟过大造成严重的空间浪费。

    1. void append(const char* str)
    2. {
    3. 	size_t n = _size + strlen(str);
    4. 	if (n > _capacity)
    5. 	{
    6. 		reserve(n * 1.5);
    7. 	}
    8. 	strcat(_str, str);
    9. 	_size = n;
    10. 	_str[_size + 1] = '/0';
    11. }

    +=的运算符重载实现依靠append函数实现，最后返回*this指针

    1. string& operator+=(const char* str)
    2. {
    3. 	append(str);
    4. 	return *this;
    5. }

    5.resize函数

    需要考虑三种情况：

    1.重新设置的size大于本身size

    2.重新设置的size等于本身size

    3.重新设置的size小于本身size

    大于等于本身时，我们可以直接reverse扩容，然后把ch中的值循环尾插到最后，然后在空间最后一位加入‘\0’作为结束标志，并且把size改变为现在的大小；小于更加简单，只需要把设置缩减的位置处变为‘\0’，size改变即可。

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

    6.c_str返回string类中数组的地址

    设计这个函数就是为了通过指针的形势来访问string类中存储数组的成员变量。

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

    7.迭代器

     不同的迭代器的本质不一定相同，但是他们归根到底是为了得到头或者尾的位置，想要通过以一种类似于数组的操作进行对类对象内容的访问。

    而因为这string类存储是通过数组实现的，所以我们返回数组指针就可以实现迭代器所想要满足的要求。

    所以我们将char*重定义为iterator，iterator在c++中可进行相关迭代器的操作。 

    typedef char* iterator;
    1. iterator begin()
    2. {
    3. 	return &_str[0];
    4. }
    5.  
    6. iterator end()
    7. {
    8. 	return &_str[_size];
    9. }

     for范围的实现本质就是迭代器，上下两个访问变量的本质其实是没有区别的。

    1. void test_string2()
    2. {
    3. 	string s1("hello world");
    4. 	string::iterator it = s1.begin();
    5. 	while (it < s1.end())
    6. 	{
    7. 		(*it)++;
    8. 		it++;
    9. 	}
    10. 	cout << s1.c_str() << endl;
    11. 	for (auto& ch : s1)
    12. 	{
    13. 		ch--;
    14. 	}
    15. 	cout << s1.c_str() << endl;
    16. }

    8.指定位置插入

    1.插入一个字符

    因为是在中间某个位置插入一个元素，以至于该位置后面的内容都要往后移动一位，即前一位的数给后面一位，但是如果从前往后替换内容会被干扰，所以我们是从后往前替换。

    如果是插入到最后面，那么其实就是尾插的逻辑设计；如果是插入到其他位置就从后往前插入，在此会出现一个操作的问题：插入在前一位，我们要知道可能会出现越界访问的问题。

    针对越界访问问题，我们需要好好讲讲。

    如果我们设置从插入位置处向后复制给后一位，那么：设置的end是size大小，到达在pos处后还会判断，end+1处的值赋予end处的值，之后end--，end>=pos进行赋值，这样是可以实现部分的；但是当pos是0时，end到达pos处，赋值给pos后一位后，end变成了-1，但是size_t是无符号整型啊，所以永远大于0，循环一直停不下来。

    解决方法有两个：1.把比较的两个值end和pos都变成int型，这样负数也纳入考虑了，但是设计不太符合正常思考的要求，因为我们知道size的大小不会出现负数，而我们为了这样一个特例强行转化成负数判断有点浪费；所以另一种方法是不要将等号作为边界判断的条件，因此我们end计入的是size+1，也意味着我们是把end-1的内容赋值给end处，不断end--进行循环。（那么当pos等于0，我们的end=1时，0处的数据就已经赋值到1处了，最后end--变为0跳出循环结束）

    最后注意修改size的大小

    1. string insert(size_t pos, char ch)
    2. {
    3. 	assert(pos <= _size);
    4. 	if (_size+1 > _capacity)
    5. 	{
    6. 		reserve(_size + 1 * 1.5);
    7. 	}
    8. 	size_t end = _size + 1;
    9. 	while (end>pos)
    10. 	{
    11. 		_str[end] = _str[end-1];
    12. 		end--;
    13. 	}
    14. 	_str[pos] = ch;
    15. 	_size++;
    16. 	return *this;
    17. }

    2.插入字符串

    插入一串字符也是，先判断是否需要扩容，如果需要就调用扩容函数；此外也需要注意插入到0处的数组越界问题；所以我们不考虑循环中判断条件出现=插入位置的判断，与插入一个字符的逻辑大差不差。

    1. string& insert(size_t pos, const char* str)
    2. {
    3. 	assert(pos <= _size);
    4. 	size_t n = _size + strlen(str);
    5. 	if (_size + 1 > _capacity)
    6. 	{
    7. 		reserve(n * 1.5);
    8. 	}
    9. 	size_t end = _size + 1;
    10. 	while (end > pos)
    11. 	{
    12. 		_str[end + strlen(str) - 1] = _str[end - 1];
    13. 		end--;
    14. 	}
    15. 	for (int i = 0; i < strlen(str); i++)
    16. 	{
    17. 		_str[end++] = str[i];
    18. 	}
    19. 	_size = n;
    20. 	return *this;
    21. }

    9.删除字符串

    对比STL中的string类的删除函数，删除实现时会有一个npos，该值为-1，是为了实现不需要传入任何值便可以全部删除的缺省参数。npos便设置为全局静态变量，如果全局变量放在成员变量中，需要在类的外面进行初始化，但是C++对整型类型开放权限，其可在内部直接赋值。

    1. private:
    2. 		char* _str;
    3. 		size_t _size;
    4. 		size_t _capacity;
    5.  
    6. 		const static size_t npos = -1;

    删除的形式有三种：

    1. 没有传入删除到哪的参数，所以后面的数都要删除

    2.传入删除到哪的参数足够大，后面的数都要删除

    3.传入删除到哪的参数不大，后面的数还要往前补上

    实现方法：

    第1和第2其实都是把size大小改成pos，在最后数组加入‘\0’；第3则是把后面的补齐前面的，从前往后赋值，最后注意修改size的大小。

    1. string& erase(size_t pos, size_t len = npos)
    2. {
    3. 	assert(pos < _size);
    4. 	if (len == npos || pos + len >= _size - pos)
    5. 	{
    6. 		_size = pos;
    7. 		_str[_size] = '\0';
    8. 	}
    9. 	else
    10. 	{
    11. 		size_t begin = pos + len;
    12. 		while (begin <= _size)
    13. 		{
    14. 			_str[begin - len] = _str[begin++];
    15.  
    16. 		}
    17. 		_size -= len;
    18. 	}
    19. 	return *this;
    20. }

    10.find函数

    1.找一个字符

    1. size_t find(const char ch, size_t pos = 0) const
    2. {
    3. 	assert(pos < _size);
    4. 	while (pos < _size)
    5. 	{
    6. 		if (_str[pos] == ch)
    7. 		{
    8. 			return pos;
    9. 		}
    10. 		pos++;
    11. 	}
    12. 	return npos;
    13. }

    2.找一串字符

    1. size_t find(const char* str, size_t pos = 0) const
    2. {
    3. 	const char* ptr = strstr(_str + pos, str);
    4. 	if (ptr == nullptr)
    5. 		return npos;
    6. 	else
    7. 		return ptr - _str;
    8. }

    11.清空函数和判空函数

    1.清空函数

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

    2.判空函数

    1. bool empty() const
    2. {
    3. 	if (_size == 0)
    4. 		return true;
    5. 	else
    6. 		return false;
    7. }

    12.逻辑比较运算符重载

    1. bool operator<(const string& s) const
    2. {
    3. 	size_t i = 0;
    4. 	while (i < _size && i < s._size)
    5. 	{
    6. 		if (_str[i] < s._str[i])
    7. 			return true;
    8. 		else if (_str[i] > s._str[i])
    9. 			return false;
    10. 		i++;
    11. 	}
    12. 	if (_size < s._size)
    13. 		return true;
    14. 	return false;
    15. }
    1. bool operator>=(const string& s)
    2. {
    3. 	return !(*this < s);
    4. }
    1. bool operator==(const string& s)
    2. {
    3. 	size_t i = 0;
    4. 	while (i < _size && i < s._size)
    5. 	{
    6. 		if (_str[i] != s._str[i])
    7. 			return false;
    8. 		i++;
    9. 	}
    10. 		return true;
    11. }
    12.  
    13. bool operator!=(const string& s)
    14. {
    15. 	return !(*this == s);
    16. }
    1. bool operator>(const string& s)
    2. {
    3. 	return !(*this <= s);
    4. }
    1. bool operator<=(const string& s)
    2. {
    3. 	return (*this == s)|| (*this < s);
    4. }

    13.流提取和流插入

    需要用全局函数实现，因为如果放到类中。this指针优先于其他，导致实现函数执行时非常别扭。不一定需要通过友元才行，实现的string类就不需要，因为我们可以通过string和[]的运算符重载找到每个元素的地址。

    1.流插入

    1. ostream& operator<<(ostream& out, const string& s)
    2. {
    3. 	for (size_t i = 0; i < s.size(); i++)
    4. 	{
    5. 		out << s[i];
    6. 	}
    7. 	return out;
    8. }

    2. 流提取

    不可以直接像流插入函数逻辑实现，in提取的不会带空格和‘\n’，他们会自动忽略，如果按照下面注释掉的代码跑，该函数会出错误。那么应该通过in的get函数，一个一个提取字符的内容，如果内容是空格或者换行则停止。

    1. istream& operator>>(istream& in, string& s) //cin不会得到空格，直接跳过的
    2. {
    3. 	/*char ch = in.get();
    4. 	while (ch != ' ' && ch != '\n')
    5. 	{
    6. 		s += ch;
    7. 		ch = in.get();
    8. 	}
    9. 	return in;*/
    10. 	s.clear();
    11. 	char buff[128] = { "\0" };
    12. 	size_t i = 0;
    13. 	char ch = in.get();
    14. 	while (ch != ' ' || ch != '\n')
    15. 	{
    16. 		if (i == 127)
    17. 		{
    18. 			s += buff;
    19. 			i = 0;
    20. 		}
    21. 		buff[i++] = ch;
    22.  
    23. 		ch = in.get();
    24. 	}
    25. 	if (i >= 0)
    26. 	{
    27. 		buff[i] = '\0';
    28. 		s += buff;
    29. 	}
    30. 	return in;
    31. }
  • 相关阅读:
    微服务的艺术：构建可扩展和弹性的分布式应用
    Elasticsearch：什么是检索增强生成 - RAG？
    2022-08-19 Mysql--preparedStatement(预编译)
    2022年Java面试题最新整理，附白话答案
    Druid 任意文件读取 （CVE-2021-36749）
    线段树维护势能类 / 均摊类问题：CF403E
    u盘就能用：RadiAnt DICOM Viewer CD/DVD 2023.1
    Java程序设计复习提纲（上：入门语法）
    速度收藏，Fiddler详细使用教程出炉！
    图文详细介绍:使用IDEA通过插件创建流程图解决Activiti工作流部署审批等操作
  • 原文地址：https://blog.csdn.net/m0_63488627/article/details/127777610