深度学习 string 类之模拟实现一个 string 类（C++）

于 2024-08-15 22:42:22 发布
阅读量523 收藏 6
点赞数 19
分类专栏： 面向对象程序设计(C++) 文章标签： c++ 开发语言 深度学习 string类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80689220/article/details/141025458
版权

在学习 string 类时我们认识了很多关于 string 类的接口，这些接口可以很好的帮助我们解决问题并简化代码，所以接下来我们要自行实现一个 string 类来加深对 string 类的理解 

关于 string 类的详细讲解参考博文：面向对象程序设计(C++)之 String 类

1. 构造与析构函数

string 类中的构造函数通常有无参与带参构造，这里我们都进行实现并且整合优化

using namespace std;
namespace bit
{
	class string
	{
	public:
		//无参构造函数
		string()
			:_str(new char[1] {'\0'})
			,_size(0)
			,_capacity(0)
		{}
		//带参构造
		string(const char* str)
		{
			//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
			_size = strlen(str);
			_capacity = _size;
			str = new char[_capacity + 1];
			strcpy(_str, str);//将str拷贝给_str 
		}
		//全缺省构造函数,上面二者合并
		string(const char* str = "")
		{
			//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
			_size = strlen(str);
			_capacity = _size;
			str = new char[_capacity + 1];
			strcpy(_str, str);//将str拷贝给_str 
		}
        //拷贝构造函数
        string(const string& s)//深拷贝
        {
	       _str = new char[s._capacity + 1];//多开一个空间存储'/0'
	       strcpy(_str, s._str);
	       _size = s._size;
	       _capacity = s._capacity;
        }
		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
	
	private:
		char* _str;//字符串数组
		size_t _size;//长度
		size_t _capacity;//容量
	};
}

2. 遍历的实现

string 遍历有下标遍历、迭代器遍历与范围for遍历，这里我们一一实现

范围for的底层逻辑实际就是迭代器，所以模拟实现一个迭代器的操作就可以使用二者，下标遍历需要模拟实现 [] 符号的重载，然后使用 for 循环遍历即可  

using namespace std;
namespace bit
{
	class string
	{
	public:
        //迭代器
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}
		无参构造函数
		//string()
		//	:_str(new char[1] {'\0'})
		//	,_size(0)
		//	,_capacity(0)
		//{}
		带参构造
		//string(const char* str)
		//{
		//	//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
		//	_size = strlen(str);
		//	_capacity = _size;
		//	str = new char[_capacity + 1];
		//	strcpy(_str, str);//将str拷贝给_str 
		//}
		//全缺省构造函数,上面二者合并
		string(const char* str = "")
		{
			//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
			_size = strlen(str);
			_capacity = _size;
			str = new char[_capacity + 1];
			strcpy(_str, str);//将str拷贝给_str 
		}
		//拷贝构造函数
		string(const string& s)//深拷贝
		{
			_str = new char[s._capacity + 1];//多开一个空间存储'/0'
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
		const char* c_str() const
		{
			return _str;
		}

		//返回长度
		size_t size()
		{
			return _size;
		}
		//返回容量
		size_t capacity()
		{
			return _capacity;
		}
		//下标实现[] 返回引用可读可写
		char& operator[](size_t pos)
		{
			assert(pos < _size);//防止越界
			return _str[pos];
		}
		//只读类型
		char& operator[](size_t pos) const
		{
			assert(pos < _size);//防止越界
			return _str[pos];
		}

	private:
		char* _str;//字符串数组
		size_t _size;//长度
		size_t _capacity;//容量
		static const size_t npos;
	};
}

void test_string_1()
{
	string s1;
	string s2("manbo");
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
	//模拟实现遍历
	for (auto e : s2)
	{
		cout << e << endl;
	}
	cout << endl;

	string::iterator it = s2.begin();
	while (it != s2.end())
	{
		cout << *it << " ";
	}
	cout << endl;
}

3. 基础函数的实现 

实现在字符串一些基础函数函数，如push_back、insert函数等

关于string类的所以函数详情见 string类 ，这里我们实现的有在指定位置插入字符/字符串，在指定位置删除字符/字符串，查找指定字符/字符串的位置，模拟实现比较两字符串(ASCII码)，重载流插入流提取，在容量不足时扩容

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<assert.h>

using namespace std;
namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}
		无参构造函数
		//string()
		//	:_str(new char[1] {'\0'})
		//	,_size(0)
		//	,_capacity(0)
		//{}
		带参构造
		//string(const char* str)
		//{
		//	//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
		//	_size = strlen(str);
		//	_capacity = _size;
		//	str = new char[_capacity + 1];
		//	strcpy(_str, str);//将str拷贝给_str 
		//}
		//全缺省构造函数,上面二者合并
		string(const char* str = "")
		{
			//capacity 中不包含'/0',所以在开辟_str所需空间时才会多开一个存储'\0'
			_size = strlen(str);
			_capacity = _size;
			str = new char[_capacity + 1];
			strcpy(_str, str);//将str拷贝给_str 
		}
		//拷贝构造函数
		string(const string& s)//深拷贝
		{
			_str = new char[s._capacity + 1];//多开一个空间存储'/0'
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

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

		//返回长度
		size_t size()
		{
			return _size;
		}
		//返回容量
		size_t capacity()
		{
			return _capacity;
		}
		//清除数据不缩小容量
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
		//下标实现[] 返回引用可读可写
		char& operator[](size_t pos)
		{
			assert(pos < _size);//防止越界
			return _str[pos];
		}
		//只读类型
		char& operator[](size_t pos) const
		{
			assert(pos < _size);//防止越界
			return _str[pos];
		}

	private:
		char* _str;//字符串数组
		size_t _size;//长度
		size_t _capacity;//容量
		static const size_t npos;
	};
}

3.1 增删查改

插入：insert、append、push_back、operator+=

删除：erase

扩容：reserve

查找：find

取出指定长度指定位置字符串：substr

插入：

1. insert 

insert 函数是在指定位置插入字符/字符串，模拟实现的思路是讲指定位置之后的字符均向后移动所需插入字符/字符串长度，使其预留出来的长度刚好满足插入指定字符/字符串，最终完成插入

需要注意的是：在容量不够时需要扩容，并且需要根据实际大小来扩容，还要注意移动数据时不能出现下标越界，例如代码中注释的情况，C语言中的隐式类型转换可能导致下标越界

void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);
	//空间不够就会扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	//依次挪动数据
	//size_t end = _size;
	//while ((int)pos <= end)//防止隐式类型转换将无符号转变为有符号，导致end为-1时仍然在比较
	//{
	//	_str[end + 1] = _str[end];
	//	end--;
	//}
	size_t end = _size + 1;
	while (pos < end)//解决方法二
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
}
void string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	//扩容,小于两倍按二倍扩容,大于二倍需要多少扩容多少
	if (len + _size > _capacity)
	{
		reserve((len + _size) > 2 * _capacity ? (len + _size) : 2 * _capacity);
	}

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

	for (size_t i = 0; i < len; i++)
	{
		_str[pos + i] = str[i];
	}
	_size += len;
}
2. append

append 函数功能是在字符串末尾添加字符串，所以直接扩容后拷贝所要添加的字符串即可

void string::append(const char* str)
{
	size_t len = strlen(str);
	if ((len + _size) > _capacity)
	{
		//如果所需空间比原空间容量两倍还大那么需要多少开多少，否则按照原空间容量的二倍扩容
		reserve((len + _size) > _capacity * 2 ? (len + _size) : _capacity * 2);
	}
	strcpy(_str + _size, str);//直接在结尾拷贝输入的字符串即可
	_size += len;
}
3. operator+=

operator+=就是直接在原有字符串后添加字符/字符串，可以复用push_back 函数实现

string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}
string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}
4. push_back 

push_back函数是尾插函数，需要注意的是，在插入完成之后需要在末尾添加'\0'，以保证判断字符串结束，还要注意扩容

void string::push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
}

删除

erase 函数是在指定位置删除指定长度字符/字符串，需要注意的是，当给定长度超过原字符串长度，那么就直接删除剩余字符即可；如果不超出那么就直接覆盖即可

void string::erase(size_t pos, size_t len)
{
	assert(pos < _size);
	if (len >= _size + pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (size_t i = pos + len; i < _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size -= len;
	}
}

扩容

reserve 函数的目的是保证时刻的容量都是充足的，多开一个空间是为了存储'\0'

const size_t npos = -1;
void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		//创建新数组，拷贝原数组数据，释放原数组，将原数组指向新数组
		char* tmp = new char[_capacity + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

查找

find 函数的目的是查找指定字符/字符串，如果匹配则返回其下标/起始位置下标，不匹配返回npos（默认值-1）

size_t string::find(char ch, size_t pos)
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
		return npos;
	}
}
size_t string::find(const char* str, size_t pos)
{
	assert(pos < _size);
	
	const char* ptr = strstr(_str + pos, str);
	if (ptr == nullptr)
	{
		return npos;
	}
	else
	{
		//指针相减返回下标
		return ptr - _str;
	}
}

取出指定长度指定位置字符串 

substr 函数是在函数内部创建一个名为 sub 的 string 类，然后拷贝需要取出的元素即可，需要注意的是，不能使用默认构造函数，因为默认构造函数是浅拷贝，要自己写一个构造函数以达到深拷贝的目的

//注意此时为浅拷贝,需要显式定义拷贝构造函数使其成为深拷贝
string string::substr(size_t pos, size_t len)
{
	assert(pos < _size);
	
	//如果超出字符串范围则更新len的值
	if (len > _size - pos)
	{
		len = _size - pos;
	}
	string sub;
	sub.reserve(len);
	for (size_t i = 0; i < len; i++)
	{
		sub += _str[pos + i];
	}
	return sub;
}

3.2 比较字符串

通过重载 >、<、>=、<=、==、!= 来实现比较两字符串

这里使用了 strcmp 函数首先实现两个基本函数，之后的函数复用即可

//先实现小于和等于，之后的函数可以不断复用即可
bool operator<(const string& s1, const string& s2)
{
	//strcmp 直接比较两字符串，根据ASCII码来比较
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator>(const string& s1, const string& s2)
{
	return !(s1 <= s2);
}
bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || s1 == s2;
}
bool operator>=(const string& s1, const string& s2)
{
	return !(s1 < s2);
}
bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

3.3 流提取与流插入

通过重载 >> 与 << 来实现 string 类的流提取与流插入

流插入直接使用范围 for 来逐次插入即可，要注意的是流提取，cin 不能识别空格与换行，需要使用 get 函数逐个插入，并且要注意扩容次数不宜太多，所以这里模拟了一个缓冲区，创建了一个 buff 数组，直接先插入 buff 数组，最后将 buff 数组插入到原字符串即可

ostream& operator<<(ostream& out, const string& str)
{
	for (auto ch : str)
	{
		out << ch;
	}
	return out;
}
//istream& operator>>(istream& in, string& str)
//{
//	str.clear();

//	char ch;
//	//in>>ch;cin默认提取不到换行与空格，所以使用 get 函数逐个字符提取
//	ch = in.get();
//	while (ch != ' ' && ch != '\n')
//	{
//		str += ch;
//		ch = in.get();
//	}
//	return in;
//}
//减少扩容次数
istream& operator>>(istream& in, string& str)
{
	str.clear();
	const int N = 256;
	char buff[N];
	int i = 0;
	char ch;
	//in>>ch;cin默认提取不到换行与空格，所以使用 get 函数逐个字符提取
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == N - 1)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}
		ch = in.get();
	}
	if (i > 0)//当buff没有放满时
	{
		buff[i] = '\0';
		str += buff;
	}
	return in;
}

 

ZZZ_O^O
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
5. **字符串**：C++的`std::string`类提供了丰富的字符串操作，而C语言中通常使用字符数组来处理字符串。 6. **图算法**：如深度优先搜索（DFS）和广度优先搜索（BFS），以及Dijkstra算法、Floyd算法等用于求解最短...
C++模拟栈操作源程序
11-22
在实际应用中，模拟栈操作不仅可以帮助学习数据结构，还可能用于解决各种算法问题，如括号匹配、深度优先搜索（DFS）等。例如，我们可以用栈来验证一个字符串中的括号是否匹配： ```cpp bool isValid(const std::...
【C++】深度剖析string类的底层结构及其模拟实现
m0_70980326的博客
04-13 2070
深度剖析string类的底层结构及其模拟实现
C++:string类的模拟实现；浅拷贝深拷贝
qq_63159859的博客
07-31 166
文章只是把一些实现列举单独列举出来，在文章的完整的代码中，string类实现的接口还是比较丰富的！本章模拟实现是为了更好的理解string的底层实现！分享个人的学习string的过程，希望能帮助到大家！有错误的地方也希望大家指正！string是C++管理字符串的类！string是通过顺序表的方式来管理字符串，但是string需要兼容C语言类型的字符串格式，所以我们会看到我实际管理字符串的时候需要额外开辟一个空间来存放'\0'实现c_str（）函数实现对C语言字符串的转换。
【C++之string类的模拟实现】
m0_69455439的博客
03-22 923
C++学习笔记010 -- string的模拟实现各个接口
深入浅出C++ ——string类深度剖析
weixin_55051736的博客
08-31 493
不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。本章开始将带来一系列STL的学习。⭐STL是C++标准库的重要组成部分(标准库的子集），不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架，把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。。STL的主流版本有：原始版本、P. J. 版本、RW版本、SGI版本(STL源码学习，主要参考是这个版本)。........
【C++学习】string的模拟实现
weixin_63726869的博客
11-28 911
详细介绍了string类中部分接口的实现原理。
【C++】模拟实现STL中的string类
talk less, code more
01-20 1108
模拟实现C++中的string类
C++ STL学习之【vector的模拟实现】
北 海的博客
04-02 4161
vector是STL中的容器之一，其使用方法类似于数据结构中的顺序表，得益于范型编程和C++特性的加持，vector更强大、更全能；在模拟实现vector时，还需要注意许多细枝末节，否则就很容易造成重复析构及越界访问
C++ string类（二）及深浅拷贝
weixin_59215611的博客
02-28 888
string类模拟实现各类方法以及代码，以及浅拷贝深拷贝的学习
C++ STL学习之【string的模拟实现】
北 海的博客
03-01 2264
string本质上就是一个专注于存储字符的顺序表，使用起来很方便；但在模拟实现string时，有许多值得注意的点，下面就来看看string类是如何诞生的吧
【c++】STL—string类
最新发布
uyeonashi的博客
08-13 729
目录一、标准库中的string类1.1string类1.2 auto和范围forauto关键字范围for1.3 string类的常用接口说明1). string类对象的常见构造2). string类对象的容量操作3). string类对象的访问及遍历操作 4). string类对象的修改操作5). string类非成员函数 二、string的模拟实现浅拷贝深拷贝string模拟实现代码其余接口模拟实现代码C语言中的字符串:C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些s
hannuotachengxu.zip_人工智能/神经网络/深度学习_Visual_C++_
08-12
汉诺塔（Hanoi Tower）算法是计算机科学中一个经典的递归问题，它与人工智能、神经网络和深度学习等现代技术虽然直接关联性不大，但作为基础算法理解，对于编程思维的培养至关重要。在Visual C++环境下，我们可以...
基于C++在Linux环境下模拟实现命令解释器(操作系统大作业)【100012698】
06-12
在本项目中，你将基于C++在Linux环境下模拟实现一个命令解释器，这是一个操作系统大作业，旨在加深对操作系统和Linux命令行的理解。这个任务的关键在于理解和实现与Linux shell相似的功能，尤其是查找指定目录下的...
c++语言聊天机器人
08-07
此外，聊天机器人可能需要实现一种或多种算法来模拟对话，比如基于规则的系统、统计学习模型（如Markov模型）或者更先进的深度学习模型（如seq2seq模型）。这些模型可以训练在大量对话数据上，以生成自然流畅的对话...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 378
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++笔记5•内存管理•
qq_64446190的博客
08-12 1055
内存管理
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1248
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 943
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值