C++ string模拟实现

最新推荐文章于 2024-11-11 23:32:39 发布
最新推荐文章于 2024-11-11 23:32:39 发布
阅读量717 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ visual studio 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eccentric_lee/article/details/123339860
版权

string模拟实现

简单复制和拷贝功能的实现

常规写法

#pragma once
#include<iostream>
using namespace std;
namespace lich
{
	class string
	{
	public:
		//初始化字符串
		string(const char* str)
			:_str(new char[strlen(str)+1])
		{
			strcpy(_str, str);
		}
		//拷贝构造
		string(const string& s)
			:_str(new char[strlen(s._str) + 1])
		{
			strcpy(_str, s._str);
		}
		//赋值构造
		string& operator=(const string& s)
		{
			//case1:
			/*if (this != &s)
			{
				delete[] _str;
				_str = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
			}*/

			// case 2:引用临时变量tmp
			if (this != &s)
			{
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;

			}
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
	private:
		char* _str;
	};
	void test_string()
	{
		string s1("hello lich");
		
		string s2(s1);

		string s3("sort");
		s1 = s3;
	}
}

简易写法

namespace lich1
{
	class string
	{
	public:
		string(const char* str)
			:_str(new char[strlen(str) + 1])
		{
			strcpy(_str, str);
		}

		//现代写法完成拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			string tmp(s._str);
			swap(_str, tmp._str);
		}

		//赋值构造
		/*string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s._str);
				swap(_str, tmp._str);
			}
			return *this;
		}*/
		string& operator=(string s)
		{
			swap(_str, s._str);
			return *this;
		}
		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
	private:
		char* _str;
	};
}

含有基本功能的string类的实现：

#pragma once
#include<iostream>
#include<string.h>
#include<assert.h>
using namespace std;

namespace lich
{
	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(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		string(const size_t n, const char ch)
			:_size(n)
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			for (size_t i = 0; i < n; i++)
			{
				_str[i] = ch;
			}
			_str[_size] = '\0';
		}


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

		//拷贝构造和赋值构造的常规写法
		/*string(const string& s)
			:_str(new char[strlen(s._str) + 1])
		{
			strcpy(_str, s._str);
		}

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				delete[] _str;
				char* tmp = new char[strlen(s._str) + 1];
				_str = tmp;
				strcpy(_str, s._str);

			}
			return *this;
		}*/

		//便捷写法
		string(const string& s)
			:_str(nullptr)
		{
			string tmp(s._str);
			swap(tmp);
		}

		string& operator=(string s)
		{
			swap(s);

			return *this;
		}

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

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

			return _str[pos];
		}

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

		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)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				if (n > _size)
				{
					reserve(n);
				}
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

		string& operator+=(char ch)
		{
			push_back(ch);

			return*this;
		}

		string& operator+=(const char* str)
		{
			append(str);

			return *this;
		}

		string& operator+=(const string& s)
		{
			*this += s._str;

			return *this;
		}

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
				reserve(newcapacity);
			}
			for (size_t i = _size + 1; i > pos; --i)
			{
				_str[i] = _str[i - 1];
			}
			_str[pos] = ch;
			++_size;

			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			for (size_t i = _size + len; i >= (pos + len); i--)
			{
				_str[i] = _str[i - len];
			}
			for (size_t i = 0; i < len; i++)
			{
				_str[pos + i] = str[i];
			}
			_size += len;

			return *this;
		}

		string& erase(size_t pos = 0, size_t len = npos)
		{
			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;
			}
			return *this;
		}

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

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

			return npos;
		}

		const char* c_str()
		{
			return _str;
		}

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}


	private:
		char* _str;
		int _size;
		int _capacity;
		static const size_t npos;
	};
	const size_t string::npos = -1;

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

		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch != '\n' && ch != ' ')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

	istream& getline(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch != '\n')
		{
			s += in.get();
			ch = in.get();
		}
		return in;
	}

	string operator+(const string& s1, const char ch)
	{
		string ret = s1;
		ret += ch;

		return ret;
	}

	//两次拷贝构造，尽量少用
	string operator+(const string& s1, const string& s2)
	{
		string ret = s1;
		ret += s2;

		return ret;
	}

	bool operator>(const string& s1, const string& s2)
	{
		size_t i1 = 0, i2 = 0;
		while (s1.size() > i1 && s2.size() > i2)
		{
			if (s1[i1] > s2[i2])
			{
				return true;
			}
			else if (s1[i1] < s2[i2])
			{
				return false;
			}
			else
			{
				++i1;
				++i2;
			}
		}
		if (i1 < s1.size())
		{
			return true;
		}
		return false;
	}
	bool operator==(const string& s1, const string& s2)
	{
		size_t i1 = 0, i2 = 0;
		while (i1 < s1.size() && i2 < s2.size())
		{
			if (s1[i1] > s2[i2])
			{
				return false;
			}
			else if (s1[i1] < s2[i2])
			{
				return false;
			}
			else
			{
				++i1;
				++i2;
			}
		}
		if (i1 == s1.size() && i2 == s2.size())
		{
			return true;
		}

		return false;
	}

	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);
	}

}
C++string模拟实现
zc331的博客
09-14 1325
C++中的string相当于是一个类模板，包含在头文件string中，具体实现在这个头文件中名为std的namespace中，所以一般在直接使用string时，展开std；那么模拟实现string时，首先要将实现的内容放在一个自己定义的命名空间里面，在这个命名空间里面再定义自己的string类；这里实现string吗，模板的主要接口功能。
C++string模拟实现增删查改功能
weixin_41368411的博客
04-21 1621
一.reserve函数 1.1功能 改变当前sting对象空间容量的大小，如果需要改变的容量大小大于string对象的实际容量，就重新申请空间，扩容，否则就不需要扩容。 1.2返回值 无返回值 1.3实现逻辑 （1）判断需要扩容的容量n是否大于当前对象的实际容量 （2）在堆上申请大小n为的空间 （3）将对象中的字符串拷贝到在堆上新开辟的空间上，并释放该字符串指向的堆上的空间 （4）改变当前对象的实际容量值 实现代码如下所示 //增容改变空间大小，只有当要增容的空间大小大于当前对象
C++ string详解+模拟实现
m0_50655389的博客
03-14 917
在本篇文章中，我们主要介绍了 C++ 中的string 类的使用以及如何进行模拟实现。string 类是 C++ 标准库提供的一个重要组件，用于处理字符串，具有丰富的功能和便利的接口。我们首先介绍了 string 类的基本用法，紧接着详细讲解了string 类的模拟实现。在这个过程中，我们深入分析了 string 类的内部实现原理，包括字符串的存储结构、构造函数和析构函数的实现等。通过模拟实现 string 类，我们可以加深对C++ 中类的设计和实现的理解，同时也能提升我们的编程能力。
模拟实现string【C++】
2301_80058734的博客
06-28 2545
在文件mystring.h和中都定义上一个命名空间mystring把mystring.h中类的声明放进命名空间，把mystring中的函数实现也放进命名空间不同源文件的同名的命名空间经过编译链接之后可以合成在一起。
c++ string模拟实现
qq_74160210的博客
01-30 1480
如果开的空间比n大，开n+1空间并拷贝_str的内容到tmp中，再把原空间释放让_str指向tmp，_capcaity=n+1。将str内容拷贝过去，size+=len（strcat在_str追加str内容时不会在末尾加'\0'）//如果pos=0，cur-->size_t，需要将'\0'一起移动。//如果pos=0，cur-->size_t，需要将'\0'一起移动。（尾插会把最后的'\0'覆盖，所以要将最后一位变成'\0'//本来是_str自己开空间，让tmp给_str打工。
C++ string类的模拟实现
08-11
C++ string类的模拟实现
C++ string 模拟实现
wws7920的博客
05-17 253
如果每读入一个字符就+ 就会频繁扩容。我们可以借鉴内存池的思想，先把读入的字符存到buff数组中，满了就一次性加入str中。对于=符号重载实现我们也可以直接用传值传参的方式，string& operator=(string str);这里itorarter begin()能翻回第一个字符的位置就可以，itorater 怎么实现的无所谓。对于>>重载，实现先清除原有字符串，再用is.get()一个一个读入（可以对入空格 回车）追加字符时要考虑扩容的问题（先申请足够大的空间，再复制原数据。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 239
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 668
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
STL之vecor的使用(超详解)
最新发布
2302_80220709的博客
11-11 499
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1715
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 292
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
【Effective C++】阅读笔记5
gma999的博客
11-07 907
Effective C++ 面向对象和模板相关章节
扫雷游戏代码分享(c基础)
lb3636363636的博客
11-11 372
创建两个.c 一个.h。
c++ 分治算法
www_dong的博客
11-08 841
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值