c++|string模拟实现

最新推荐文章于 2024-04-27 00:33:57 发布
最新推荐文章于 2024-04-27 00:33:57 发布
阅读量420 收藏 2
点赞数 1
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68201503/article/details/137109162
版权

 

目录

一、string.h

二、string.cpp

三、Test.cpp

对string的各种接口进行一个简易版的模拟实现，在模拟实现完之后对string的底层实现有了进一步的理解，了解大佬的编程写法思路。也算是对string有了一个小总结。

一、string.h

接口的声明。放在.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() const
		{
			return _str;
		}


		iterator end()
		{
			return _str + _size;
		}
		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* s = "");


		string(const string& s);


		string& operator=(string s);

		~string();


		void push_back(char c);


		string& operator+=(char c);
		string& operator+=(const string& s);

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

		void append(const char* str);


		void clear();


		void swap(string& s);

		const char* c_str()const;

		//capacity
		size_t size();

		size_t capacity();

		void resize(size_t n, char c = '\0');

		void reserve(size_t n);

		bool empty()const;



		bool operator<(const string& s);

		bool operator<=(const string& s);

		bool operator>(const string& s);

		bool operator>=(const string& s);

		bool operator==(const string& s);
		;
		bool operator!=(const string& s);

		char& operator[](size_t i);

		const char& operator[](size_t i) const;


		//返回字符第一次在字符串出现的位置
		size_t find(char c, size_t pos = 0) const;
		;
		//在pos位置插入字符c
		string& insert(size_t pos, char c);

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


		//返回子串在字符串中出现的位置
		size_t find(const char* str, size_t pos = 0);

		string substr(size_t pos = 0, size_t len = npos);

		//	删除pos位置上的元素，并返回该元素的下一个位置

		string& erase(size_t pos, size_t len = npos);


	private:

		size_t _size;
		size_t _capacity;
		char* _str;

		//静态变量可以赋值处理的前提是有const修饰，这个可以看作是编译器的特殊处理，只能适用于整形家族
		static const size_t npos = -1;

	};
	ostream& operator<<(ostream& out, const string& s);
	istream& operator>>(istream& in, string& s);
}

二、string.cpp

接口的各种实现。进行声明定义分离时，要注意格式上的变化，指定类域，声明和定义中，只有声明中可以给缺省值，定义中不能给。string的构造函数有传统写法和现代写法，现代写法更简洁，但和传统写法本质上没有太大的区别

#include "string.h"


namespace bit
{
		//string()
		//	:_str(nullptr)//不能给空，析构时会对空指针解引用，从而报错
		//	,_size(0)
		//	,_capacity(0)
		//{}

		//string()
		//	:_size(0)
		//	,_capacity(_size)
		//	,_str(new char[_capacity + 1])//这样必须给定成员变量声明顺序。
		//{}

		
		string::string(const char* s)
		{

			_size = strlen(s);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, s);
		}
		//传统写法
	/*	string(const string& s)
		{
			_str = new char[s._capacity + 1];
			_size = s._size;
			_capacity = s._capacity;

			strcpy(_str, s._str);
		}*/

		//现代写法
		string::string(const string& s)
		{
			string tmp(s._str);
			swap(tmp);
		}
		//传统写法
		//string& operator=(const string& s)
		//{
		//	if (*this != s)
		//	{
		//		char* tmp = new char[s._capacity + 1];
		//		delete[] _str;
		//		strcpy(tmp, s._str);
		//		_str = tmp;
		//		_size = s._size;
		//		_capacity = s._capacity;
		//		return *this;
		//	}
		//	return *this;
		//	
		//}

		//现代写法
		/*string& operator=(const string s)
		{
			string tmp(s._str);

			swap(tmp);
			return *this;
		}*/

		string& string::operator=(string s)
		{
			swap(s);
			return *this;
		}
		string::~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		//modify

		void string::push_back(char c)
		{
			if (_size == _capacity)//初始化容量以及判断容量是否满了
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				/*		if (_str != "")
						{
							char* tmp = new char[newcapacity + 1];
							memcpy(tmp, _str, _size);
							delete[] _str;
							_str = tmp;
							_capacity = newcapacity;
						}*/
				reserve(newcapacity);
			}
			_str[_size] = c;
			_size++;
			_str[_size] = '\0';

		}
	    string& string::operator+=(char c)
		{
			push_back(c);
			return *this;
		}


		string& string::operator+=(const string& s)
		{
			if (_size + s._size > _capacity)
			{
				reserve(_size + s._size);
			}
			strcpy(_str + _size, s._str);
			_size += s._size;
			return *this;
		}
		string& string::operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		void string::append(const char* str)
		{
			if (_size + strlen(str) > _capacity)
			{
				reserve(_size + strlen(str));
			}
			strcpy(_str + _size, str);
			_size += strlen(str);
		}

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

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

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

		//capacity
		size_t string::size()
		{
			return _size;
		}
		size_t string::capacity()
		{
			return _capacity;
		}
		void string::resize(size_t n, char c)
		{
			if (n > _capacity)
			{
				reserve(n);
				for (int i = _capacity; i < n; i++)
					push_back(c);
			}
			else if (n > _size && n < _capacity)
			{
				for (int i = _size; i < n; i++)
					push_back(c);
			}
			else if (n < _size)
			{
				_str[n] = '\0';
			}
		}
		void string::reserve(size_t n)
		{
			if (n > _capacity)
			{

				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				//_size = strlen(tmp);
				_capacity = n;
			}
		}
		bool string::empty()const
		{
			return _str == "";
		}



		bool string::operator<(const string& s)
		{
			return strcmp(_str, s._str) < 0;
		}
		bool string::operator<=(const string& s)
		{
			return !(*this > s);
		}
		bool string::operator>(const string& s)
		{
			return strcmp(_str, s._str) > 0;
		}
		bool string::operator>=(const string& s)
		{
			return !(*this < s);
		}
		bool string::operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}
		bool string::operator!=(const string& s)
		{
			return !(strcmp(_str, s._str) == 0);
		}
		char& string::operator[](size_t i)
		{
			return _str[i];
		}
		const char& string::operator[](size_t i) const
		{
			return _str[i];
		}

		//返回字符第一次在字符串出现的位置
		size_t string::find(char c, size_t pos) const
		{
			assert(pos <= _size);
			for (int i = pos; i < _size; i++)
			{
				if (_str[i] == c)
					return i;
			}
			return npos;
		}
		//在pos位置插入字符c
		string& string::insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			if (pos == _size)
				push_back(c);
			else
			{
				size_t len = _size - pos;
				while (len)
				{
					_str[pos + len] = _str[pos + len - 1];
					len--;
				}
				_str[pos] = c;
			}
			_size++;
			_str[_size] = '\0';
			return *this;

		}
		//在pos位置插入字符串
		string& string::insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);

			if (len + _size >= _capacity)
			{
				reserve(len + _size);
			}
			if (pos == _size)
			{
				append(str);
			}
			else
			{
				size_t ilen = _size - pos;
				while (ilen)
				{
					_str[pos + ilen + len] = _str[pos + ilen];

					ilen--;
				}
				for (int i = pos, j = 0; i < pos + len; i++, j++)
				{
					_str[i] = str[j];
				}

			}
			_size += len;
			_str[_size] = '\0';
			return *this;
		}

		//返回子串在字符串中出现的位置
		size_t string::find(const char* str, size_t pos)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (pos + len > _size)
				return npos;
			else
			{
				size_t fpos = find(str[0], pos);
				for (int i = fpos, j = 0; i < fpos + len; i++, j++)
				{


					if (str[j] != _str[i])
						return npos;

				}
				return fpos;
			}
		}
		string string::substr(size_t pos, size_t len)
		{
			assert(pos <= _size);
			string tmp;
			size_t end = pos + len;
			//if (len == npos || len >= _size - pos)
			//{
			//	tmp.reserve(_size - pos);
			//	strcpy(tmp._str, _str + pos);
			//	return tmp;

			//}
			//else
			//{
			//	memcpy(tmp._str, _str + pos, len);
			//	tmp[len] = '\0';
			//	return tmp;
			//}
			if (len == npos || len >= _size - pos)
			{
				end = _size;
			}
			tmp.reserve(end - pos);
			for (int i = pos; i < end; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}
		//	删除pos位置上的元素，并返回该元素的下一个位置

		string& string::erase(size_t pos, size_t len)
		{
			assert(pos < _size);
			if (len == npos || len > _size)
			{
				_str[pos] = '\0';
			}
			else
			{
				/*size_t length = len + pos;
				while (pos < length)
				{
					_str[pos] = _str[pos + len];
					pos++;
				}
				_str[_size - len] = '\0';*/
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}


	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto e : s)
		{
			out << e;
		}
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char buff[128];
		char ch = in.get();
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i] = ch;
			i++;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}
	
}

三、Test.cpp

测试版本，对接口进行测试，写了三个测试版本，但并没有调用全部接口，进行一番演示，大致还行，可能还有错误，也是水平有限。 

#include "string.h"
namespace bit
{
	void stringtest1()
	{
		string s("hello world");

		string::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it;
			it++;
		}
		cout << endl;
		for (auto e : s)
		{
			cout << e;
		}
		cout << endl;
		string s1(s);
		string s2 = s1;
		for (auto e : s1)
		{
			cout << e;
		}
		cout << endl;
		for (auto e : s2)
		{
			cout << e;
		}
		cout << endl;

	}
	void stringtest2()
	{
		string s("hello world");
		s += "hello world";
		for (auto e : s)
		{
			cout << e;
		}
		cout << endl;

		string s1;
		s1.push_back('a');
		s1.push_back('b');
		s1.push_back('c');
		s1.push_back('d');
		for (auto e : s1)
		{
			cout << e;
		}
		cout << endl;
		cout << (s < s1);
		cout << (s > s1);
		cout << (s == s1);
		cout << (s <= s1);
		cout << (s >= s1);
		cout << true;
	};
	void stringtest3()
	{
		string s("hello world");
		string s1 = "excuse me";
		/*s.swap(s1);
		cout << s.c_str() << " " << s1.c_str() << endl;
		cout << s.capacity() << endl;
		s.reserve(100);
		cout << s.capacity() << endl;
		s.resize(5);
		cout << s.capacity() << " " << s.c_str() << endl;;*/
		//cout << s[0];
		size_t pos = s.find("world");
		cout << pos << endl;
		cout << s.substr().c_str() << endl;
		s.insert(0, 'w');
		cout << s.c_str() << endl;
		s.insert(6, 'e');
		cout << s.c_str() << endl;
		s1.insert(0, "hello");
		cout << s1.c_str() << endl;
		s1.insert(5, "hello");
		cout << s1.c_str() << endl;
		cin >> s1;
		cout << s1;

	}
}
int main()
{
	bit::stringtest1();
    bit::stringtest2();
    bit::stringtest3();
	return 0;
}

三个测试函数的输出结果 ：

 

 

 

逸群不凡
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++中string的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
⚡【C++要笑着学】(17) 模拟实现 string：深浅拷贝 | string 模拟实现 | 传统写法与现代写法
⚡ 柠檬叶子团队
05-07 4116
本章将正式介绍深浅拷贝，在模拟实现 string 的同时带着去理解深浅拷贝。我们模拟实现 string类不是为了造更好的轮子，而是为了去学习它，理解它的本质！你自己造一次，心里会更清楚，也有利于加深对 string 的理解。...
c++模拟实现string类
北川_的博客
01-11 1337
目录string类简介模拟实现成员变量成员函数构造函数拷贝构造赋值重载析构函数迭代器普通迭代器const迭代器重载运算符[ ]代码 string类简介 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。 模拟实现 成员变量 char* _str; size_t _size; size_t _capacity; //不包含最后做标识的'\0' static const size_t npos; _s
【C++】string类模拟实现
qq_66314292的博客
09-16 1616
string类的模拟实现
C++ —— 模拟实现string类
weixin_59913110的博客
11-07 1105
本篇博客分享了笔者如何模拟实现string类的过程。其中包括最常用、最实用的接口。例如流插入、提取运算符重载、下标运算符重载、常用的构造函数、析构函数……
【C++】string的模拟实现
学了就忘是正常现象
11-16 2460
C++中string类的模拟实现。
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
【C】 初识C语言
努力学习C/C++
04-21 787
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 630
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
C语言如何⽤指针为函数传递数组？
PAP
04-25 216
C语言如何⽤指针为函数传递数组？
C++——初识模板
qq_74245477的博客
04-22 920
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 773
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
C++中的抽象类
hh121386的博客
04-23 213
C++中的抽象类
掉落回弹问题（C语言）
m0_67184754的博客
04-22 368
【代码】掉落回弹问题（C语言）
C++初识--------带你从不同的角度理解引用的巧妙之处
binhyun的博客
04-24 548
引用之顺序表与链表运用&&权限问题
C++ | Leetcode C++题解之第51题N皇后
Ddddddd_158的博客
04-26 388
C++ | Leetcode C++题解之第51题N皇后
华为OD机试真题-亲子游戏-2024年OD统一考试（C卷D卷 ）
面试高手的博客
04-24 161
宝宝和妈妈参加亲子游戏，在一个二维矩阵（N*N）的格子地图上，宝宝和妈妈抽签决定各自的位置，地图上每个格子有不同的糖果数量，部分格子有障碍物。游戏规则是妈妈必须在最短的时间（每个单位时间只能走一步）到达宝宝的位置，路上的所有糖果都可以拿走，不能走障碍物的格子，只能上下左右走。请问妈妈在最短到达宝宝位置的时间内最多拿到多少糖果（优先考虑最短时间到达的情况下尽可能多拿糖果）。可到宝宝位置，绿色线和黄色线都是最短路径6步，但黄色拿到的糖果更多，9个。之后N行，每行有N个值，表格矩阵每个位置的值。
牛客NC368 质数的计数【中等 基础数学，数论 C++/Java/Go/PHP】
最新发布
weixin_37991016的博客
04-27 180
【代码】牛客NC368 质数的计数【中等 基础数学，数论 C++/Java/Go/PHP】
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值