C++修炼之路之string模拟实现

已于 2024-04-10 22:10:31 修改
阅读量1.3k 收藏 19
点赞数 51
分类专栏： c++ 文章标签： c++
于 2024-04-10 22:09:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miwll/article/details/137592080
版权

目录

前言

一：构造函数+析构函数+拷贝构造函数

二：c_str +  size  +   capacity  +   operator= +    operator[]

三：普通迭代器 +const迭代器+范围for

四：关系操作符重载 

 五：reserve+resize

六：push_back  +  append  +  operator+=   +

七：insert+erase+swap+find+clear 

八：重载cin和cout 

九：整体代码

 十：总结

接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧

前言

在经过前面的对标准库中string类的各接口函数的简单介绍和使用后，接下来我们就将介绍关于模拟实现一个string类，去更深层次的了解标准库中string的实现，帮助我们更加了解string类，提升代码能力

一：构造函数+析构函数+拷贝构造函数

1.对于模拟实现sting 类的构造函数和拷贝构造函数时，定义的成员变量是const char *str的话，刚好适合拷贝构造函数，但对于后续的resize和reserve开空间这些等就将出现错误，还有使用c_str（c语言str系列函数都会解引用字符串str的）打印字符串时，对于无参构造的string类对象，使用const char *str的话，会直接解引用空指针的，还有const修饰的字符串时不允许修改的，所以要开辟的空间需要我们自己new出来，定义为char *str

2.对于拷贝构造函数我们不写的话，编译器默认实现的是浅拷贝(按照字节一个一个字节的拷贝)，对于内置类型浅拷贝是没问题的，但对于自定义类型浅拷贝会出现错误，这里会有两个char*指针指向同一块空间，当一个修改时另一个也为会跟着修改，而且还会析构两次，直接出错，因此就需要我们自己实现深拷贝解决

3.当实现一个无参构造和一个传参构造时，为了简化我们可以考虑实现成一个带缺省值的构造函数

对于这些问题我们更好地实现方式为

	/*string()//无参构造
		:_str(new char[1])
		,_size(0)
		,_capacity(0)
	{
		_str[0] = '\0';
	}

	string(const char *str)//传参构造
		:_size(strlen(str))
	{
		_capacity = _size + 1;
		_str = new char[_capacity+1];
        strcpy(_str,str);
	}*/

	//给缺省值的构造
	//string(const char *str=nullptr)//下面的strlen会进行解引用报错
	//string(const char *str='\0')//'\0'的ASCII码为0，直接接引用报错
	//string (const char *str="\0")//字符串的形式，可以
	string(const char* str = "")
		:_size(strlen(str))
	{
		_capacity = _size==0? 3:_size;//如果_size为0的话，下面开空间_size*2的话还是0会出错
		_str = new char[_capacity + 1];//开空间
		strcpy(_str, str);//传数据
	}

	~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	string(const string& s)//拷贝构造
		:_size(s._size)
		,_capacity(s._capacity)
	{
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;

二：c_str +  size  +   capacity  +   operator= +    operator[]

对于赋值重载可能存在的情况多样（是对已经定义的类对象的操作），主要的有以下几种

对于以上的三种情况下，我们可以分开讨论，但为了代码的不冗余，我们可以优化为直接开辟空间，拷贝数据，释放原空间，在指向新空间 ，但要注意d1=d1这种特殊情况的处理

//不修改成员变量数据的函数，尽量加const
const char* c_str()
{
	return _str;
}

size_t size()const
{
	return _size;
}
size_t capacity()const
{
	return _capacity;
}
string& operator=(const string& s)//支持连续赋值
{
	if (this != &s)//处理d1=d1的情况
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;
		_str = tmp;

		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}
const char& operator[](size_t pos)const//const对象的调用
{
	assert(pos < _size);
	return _str[pos];
}
char& operator[](size_t pos)//普通对象的调用
{
	assert(pos < _size);
	return _str[pos];
}

三：普通迭代器 +const迭代器+范围for

这里的迭代器我们实现为指针的方式，依然是左闭右开的规则，对于范围for其实在底层是转换为迭代器来实现的，所以实现了迭代器也就支持了范围for

const对象要用const迭代器来实现遍历，普通对象要调用普通迭代器或者const迭代器来实现遍历

typedef char* iterator;//普通迭代器
typedef const char* const_iterator;//const迭代器
iterator begin()
{
	return _str;
}
iterator end()
{
	return _str + _size;
}

const_iterator begin() const
{
	return _str;
}
const_iterator end() const
{
	return _str + _size;
}
void Print(const string& s)
{
	//三种遍历方式
	for (size_t i = 0; i < s.size(); i++)
	{
		cout << s[i] << " ";
	}
	cout << endl;

	string::const_iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	for (auto ch : s)
	{
		cout << ch << " ";
	}
	cout << endl;
}
void teststring2()
{
	string s1;
	string s2("hello world");
	s1 = s2;
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	for (auto ch : s2)
	{
		cout << ch << " ";
	}
	cout << endl;
	Print(s2);
}

四：关系操作符重载 

bool operator==(const string&s)const
{
	return strcmp(_str, s._str) == 0;
}
bool operator>(const string& s)const
{
	return strcmp(_str, s._str) > 0;
}
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);
}

 五：reserve+resize

reserve是开空间，resize是开空间并初始化，但这两个都要注意当开的新空间比capacity小时，不能修改capacity

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}
void resize(size_t n, char ch = '\0')
{
	if (n < _size)//删除数据，保留前n个
	{
		_size = n;
		_str[_size] = '\0';
	}
	else
	{
		if (n > _capacity)
		{
			reserve(n);
		}
		size_t i = _size;
		while (i < n)
		{
			_str[i] = ch;
			++i;
		}
		_size = n;
		_str[_size] = '\0';
	}
}

六：push_back  +  append  +  operator+=   +

在插入数据时需要时刻注意capacity，当capacity不足时，需要及时reserve扩容

void push_back(char ch)
{
	if (_size + 1 > _capacity)
	{
		reserve(_capacity*2);
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
   //insert(_size,ch);
}
void append(const char* s)
{
	size_t len = strlen(s);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, s);
	_size += len;
    //insert(_size,s);
}
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}
string& operator+=(const char* str)
{
	append(str);
	return *this;
}

七：insert+erase+swap+find+clear 

对于任意位置插入和删除，需要特别关注边界问题，插入需要及时关注capacity,及时扩容

对于插入需要注意size_t 类型会出现的一些问题，当要头插数据时，这时按照以前的方式移动的话，当pos=-1时停止，但size_t 类型的-1是整形最大值，所以要错位移动

string& insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size + 1 > _capacity)
	{
		reserve(_capacity * 2);
	}
	//这样的移动会发生错误的
	/*size_t end = _size;
	while (end >= pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}*/
	size_t end = _size + 1;
	while (end >pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
	return *this;
}
string& inster(size_t pos,const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	size_t end = _size + len;
	//挪动数据
	while (end >= pos + len)
	{
		_str[end] = _str[end - len];
		--end;
	}
	//插入拷贝
	strncpy(_str + pos, str, len);
	_size += len;
	return *this;
}
string& erase(size_t pos, size_t len = npos)
{
	if (pos == npos || pos+len>=_size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
	return *this;
}

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

size_t find(const char* str, size_t pos = 0)
{
	assert(pos <= _size);
	char* tmp = strstr(_str + pos, str);
	if (tmp == nullptr)
	{
		return npos;
	}
	return tmp - _str;
}
void clear()
{
	_str[0] = '\0';
	_size = 0;
}

八：重载cin和cout 

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

	char ch = in.get();
	char buff[128];
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[127] = '\0';
			s += buff;
			i = 0;
		}

		ch = in.get();
	}

	if (i != 0)
	{
		buff[i] = '\0';
		s += buff;
	}

	return in;
}
}

九：整体代码

https://gitee.com/lin-ciyu/cplusplus/tree/master/string2/string2

 十：总结

关于string的模拟实现就到这里了，里面有许多细节需要注意的，多练多去感受

林辞忧
关注
  • 51
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++修炼之路】vector 模拟实现
StackFrame
07-15 262
vector 容器模拟实现
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
【C++修炼之路】9. string类的模拟实现
Q1697354625
11-16 902
本篇文章是衔接上一篇string，进行string的模拟实现，其中包含了众多重载函数，以及一些实现的细节，由于上篇已经知道具体函数的含义，这一篇就以纯代码的方式进行叙述。此外，这篇还对内置类型的知识进行了进一步的扩展。此篇文章不长，大多通过直接展示代码的形式介绍了string内部函数的模拟实现，此外又添加了template的扩展知识，希望对你有所帮助。
【C++修炼之路】string 模拟实现
StackFrame
07-09 193
string 类模拟实现
【C++修炼之路】string 概述
StackFrame
07-09 247
string 简述、库函数使用、特性讲解
【C++修炼之路】8. string类详解
Q1697354625
11-03 693
详细介绍了关于string的各个函数的使用方法并举例实现。
c++修炼之路之vector模拟实现
Miwll的博客
04-14 826
在了解标准库中的vector之后，对于模拟实现vecor的各接口函数常常是面试时的重难点，在模拟实现vector的过程中主要有迭代器失效的问题，在模拟实现的vectro中是使用三指针来模拟实现vector的
C++小工修炼之路Ⅹ（string类）
weixin_43767691的博客
10-28 115
浅拷贝如何解决： 深拷贝----让每个对象都拥有自己独立的资源—拷贝的不是对象本身的内容，而是对象管理资源中的内容 a传统版解决办法，对产生对象的函数都进行深拷贝的操作 b.现代版的解决办法，代码量少，提高了代码的复用率 2.在浅拷贝的基础上，加上引用计数的方法，再加上写时拷贝，就大概可以实现浅拷贝的问题 但是不建议写这种写是拷贝的代码，因为在所有的进行写操作或者，push_back操作的代码...
【C++修炼之路】27.右值引用
Q1697354625
03-12 500
以下所要讲到的，以及右值引用的都是为了提高性能，这是其他语言所不具备的，而本文章就围绕了大量的场景将右值引用的细节分割并逐个击破。左值引用是取别名，直接起作用。右值引用是通过实现移动构造和移动赋值，在拷贝的场景中，如果是右值（将亡值），则进行资源的转移，这是间接起作用。在C++11的标准中，vector以及其他类型的容器的构造函数中，也都出现了新的函数接口：这里只贴了两种常见的容器，对于其他容器，也都有这一新接口。return 0;这是当然的，学这么长时间岂是白学？
【C++修炼之路】17.二叉搜索树
Q1697354625
02-07 624
二叉搜索树。
C++中string的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
利用C++模拟实现栈的一些函数
03-13
C++模拟实现栈
操作系统的模拟实现 C++编写
04-14
本资源用c++模拟操作系统的实现 主要内容：1.进程控制 2.分页式存储管理 3.设备管理4.文件管理 5.进程调度 有问题 联系 [email protected]
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 905
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 262
C语言如何在链表中的指定位置插⼊结点？
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 621
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值