C++ string模拟实现(部分接口)

这篇具有很好参考价值的文章主要介绍了C++ string模拟实现(部分接口)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


C++的string类是一个类模板,用于表示和操作任何字符类型的字符串。 string类内部使用字符数组来存储字符,但是所有的内存管理,分配和空终止都由string类自己处理,所以使用起来很方便。string类的长度可以在运行时改变,因为它使用动态内存分配类似于vector。

string类提供了许多成员函数和运算符重载,用于进行字符串的创建,赋值,连接,比较,查找,替换,插入,删除等操作。你可以使用下标运算符[]或at()函数来访问字符串中的单个字符。你也可以使用c_str()或data()函数来获取字符串的C风格表示形式。

string模拟实现(部分接口)

官方C++string类:(string)

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
#include <assert.h>


namespace hsl
{
	class string
	{
	public:

		typedef char* iterator;
		//构造函数
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		//string(const string& s);

		//string& operator=(const string& s);
		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

		//

		// iterator
		//返回第一个位置的指针
		iterator begin()
		{
			return _str;
		}
		//返回最后一个位置的指针
		iterator end()
		{
			return _str + _size;
		}
		/

		// modify
		//尾插字符
		void push_back(char c)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = c;
			_size++;
			_str[_size] = '\0';
		}
		//尾插字符
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}
		//尾插字符串
		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+=(const char* str)
		{
			append(str);
			return *this;
		}

		//void clear();

		//void swap(string& s);
		//以字符串的形式返回
		const char* c_str()const
		{
			return _str;
		}

		/
		
		//返回数据个数
		size_t size()const
		{
			return _size;
		}
		//返回容量大小
		size_t capacity()const
		{
			return _capacity;
		}
		//判断是否为空
		bool empty()const
		{
			return (_size == 0 || _capacity == 0);
		}
		
		//如果 n 小于当前容器大小,则内容将减少到其前 n 个元素,删除超出的元素(并销毁它们)。
//如果 n 大于当前容器大小,则通过在末尾插入所需数量的元素来扩展内容,以达到 n 的大小。如果指定了 //val,则新元素将初始化为 val 的副本,否则,它们将被值初始化。
//如果 n 也大于当前容器容量,则会自动重新分配分配的存储空间。
		void resize(size_t n, char c = '\0')
		{
			if (n < _size)
			{
				_str[_size] = c;
				_size = n;
			}
			if (n > _size)
			{
				if (n > _capacity)
				{
					reserve(n);
				}
				int x = _size;
				_size = n;

				while (x < n)
				{
					_str[x] = c;
					x++;
				}
				_str[n] = '\0';
			}
		}
		//扩容
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* ch = new char[n + 1];
				strcpy(ch, _str);
				delete[] _str;
				_str = ch;
				_capacity = n;
			}
		}

		/
		//[]重载运算符
		char& operator[](size_t index)
		{
			assert(index < _size);
			return _str[index];
		}
		//[]重载运算符(重载函数)
		const char& operator[](size_t index)const
		{
			assert(index < _size);
			return _str[index];
		}
		/

		//relational operators
		//<重载运算符
		bool operator<(const string& s)
		{
			return strcmp(_str, s._str) < 0;
		}
		//<=重载运算符
		bool operator<=(const string& s)
		{
			return (_str < s._str) || (_str == s._str);
		}
		//>重载运算符
		bool operator>(const string& s)
		{
			return !((_str <= s._str));
		}
		//>=重载运算符
		bool operator>=(const string& s)
		{
			return !(_str < s._str);
		}
		//==重载运算符
		bool operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}
		//!=重载运算符
		bool operator!=(const string& s)
		{
			return !(_str == s._str);
		}

		// 返回c在string中第一次出现的位置

		//size_t find(char c, size_t pos = 0) const;

		// 返回子串s在string中第一次出现的位置

		//size_t find(const char* s, size_t pos = 0) const;

		// 在pos位置上插入字符c/字符串str,并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			int end = (int)_size;
			while (end >= (int)pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = c;
			_size++;
			return *this;
		}

		//在pos位置插入字符串
		string& insert(size_t pos, const char* str)
		{

			assert(pos <= _size);
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				--end;
			}
			_size += len;
			int n = pos + len;
			int i = 0;
			while (pos < n)
			{
				_str[pos++] = str[i++];
			}

			return *this;
		}
		
		// 删除pos位置上的元素,并返回该元素的下一个位置
		string& erase(size_t pos, size_t len)
		{
			assert(pos < _size);
			size_t end = _size;
			//assert((end - pos) >= len);
			if (pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				while (pos <= (end - len + 1))
				{
					_str[pos] = _str[pos + len];
					pos++;
				}
				_size -= len;
			}
			return *this;
		}
		//清空数据(不删除数据)
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
		//传统写法
		s1(s2)
		//string(const string& s)
		//{
		//	_str = new char[s._capacity + 1];
		//	strcpy(_str, s._str);
		//	_size = s._size;
		//	_capacity = s._capacity;

		//}
		s1 = s2;
		//string& operator=(const string& s)
		//{
		//	if (this != &s)
		//	{
		//		char* tmp = new char[s._capacity+1];
		//		strcpy(tmp, s._str);
		//		delete[] _str;
		//		_str = tmp;
		//		_size = s._size;
		//		_capacity = s._capacity;
		//	}
		//	return *this;
		//}	
		//交换
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		//s1(s2)
		//拷贝构造
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}
		//s1 = s2;
		//赋值重载
		string& operator=(string s)
		{
			swap(s);

			return *this;
		}


	private:
		char* _str;//字符指针
		size_t _size;//字符个数
		size_t _capacity;//容量
	};
    //输出流
	ostream& operator<<(ostream& _cout, const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			cout << s[i];
		}
		return _cout;
	}

	//istream& operator>>(istream& _cin, string& s)
	//{
	//	s.clear();
	//	char ch;
	//	ch = _cin.get();
	//	while (ch != ' ' && ch != '\n')
	//	{

	//		s += ch;
	//		ch = _cin.get();
	//	}
	//	return _cin;
	//}
   //输入流
	istream& operator>>(istream& _cin, string& s)
	{
		s.clear();
		char ch;
		char buff[129];
		int i = 0;
		ch = _cin.get();
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 128)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = _cin.get();
		}
		if (i != 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return _cin;
	}

	void test_string3()
	{
		string s1;
		cin >> s1;
		cout << s1 << endl;
		cout << s1.size() << endl;
		cout << s1.capacity() << endl;

	}

}

int main()
{	
	hsl::test_string3();
	return 0;
}

(本章完)文章来源地址https://www.toymoban.com/news/detail-636373.html

到了这里,关于C++ string模拟实现(部分接口)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • [C/C++]string类常用接口介绍及模拟实现string类

            在C语言中,字符串是以\\\'\\0\\\'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 C++中对于string的定义为: typedef ba

    2024年03月22日
    浏览(80)
  • 【C++】手撕string(string的模拟实现)

    手撕string目录: 一、 Member functions 1.1 constructor 1.2  Copy constructor(代码重构:传统写法和现代写法) 1.3 operator=(代码重构:现代写法超级牛逼) 1.4 destructor 二、Other member functions 2.1 Iterators(在string类中,迭代器基本上就是指针) 2.1.1 begin() end() 2.1.2  范围for的底层

    2024年02月08日
    浏览(44)
  • C++——string模拟实现

    前言:上篇文章我们对string类及其常用的接口方法的使用进行了分享,这篇文章将着重进行对这些常用的接口方法的内部细节进行分享和模拟实现。 目录 一.基础框架 二.遍历字符串 1.[]运算符重载 2.迭代器 3.范围for 三.常用方法 1.增加 2.删除 3.调整 4.交换 5.查找 6.截取 7.比较

    2024年03月12日
    浏览(37)
  • 【C++】模拟实现string

      目录 🌞专栏导读 🌛定义string类  🌛构造函数 🌛拷贝构造函数 🌛赋值函数 🌛析构函数  🌛[]操作符重载  🌛c_str、size、capacity函数  🌛比较运算符重载   🌛resize与reserve函数 🌛push_back、append函数  🌛insert函数  🌛erase函数 🌛find函数  🌛swap函数 🌛clean函数  🌛

    2024年02月14日
    浏览(43)
  • 【C++】string模拟实现

    个人主页🍖:在肯德基吃麻辣烫 本文带你进入string的模拟实现,对于string,是我们深入学习STL的必要途径。 我在模拟实现string时,成员变量如下: 1.1 无参构造(默认构造) 构造时不进行任何初始化,则默认为空字符串 比如: bit::sring s1; 1.2 普通构造 思路: 1.先新申请一块空

    2024年02月16日
    浏览(46)
  • 【小梦C嘎嘎——启航篇】string常用接口的模拟实现

        😎博客昵称:博客小梦 😊最喜欢的座右铭:全神贯注的上吧!!! 😊作者简介:一名热爱C/C++,算法等技术、喜爱运动、热爱K歌、敢于追梦的小博主! 😘博主小留言:哈喽! 😄各位CSDN的uu们,我是你的博客好友小梦,希望我的文章可以给您带来一定的帮助,话不

    2024年02月11日
    浏览(31)
  • C++ 模拟实现string类

    目录 一、类的定义 二、初始化销毁 1、构造函数 2、辨析三种定义  3、析构函数 三、赋值  1、拷贝构造函数 2、赋值运算符 四、成员访问  operator[ ] 五、比较大小判断相等 六、容量操作  1、size() 2、reserve 3、push_back 4、append 5、加等运算符  6、C风格 7、insert 插入字符  插入

    2024年02月05日
    浏览(46)
  • 【C++】——string的模拟实现

    前言: 在之前的学习中,我们已经对string类进行了简单的介绍,大家只要能够正常使用即可。但是在面试中,面试官总喜欢让学生自己 来模拟实现string类,最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。因此,接下来我将带领大家手动模拟实现一下

    2024年02月05日
    浏览(38)
  • C++ string类模拟实现

    目录 string类成员变量 一.构造函数 二.析构函数 三.拷贝构造 四.size(),capacity() 五.operator [ ] 六. operator =  七.字符串比较  八.reserve() 九.push_back(),append() 十.operator+=  十一.insert()  十二.迭代器  十二.erase() 十三.swap()  十四.find() 十五.流提取,流输出 十六

    2024年02月14日
    浏览(36)
  • 【C++】:string的模拟实现

    朋友们、伙计们,我们又见面了,本期来给大家解读一下有关string的模拟实现,如果看完之后对你有一定的启发,那么请留下你的三连,祝大家心想事成! C 语 言 专 栏: C语言:从入门到精通 数据结构专栏: 数据结构 个  人  主  页 : stackY、 C + + 专 栏   : C++ Linux 专

    2024年02月08日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包