【C++ —— string的模拟实现】

最新推荐文章于 2024-07-25 12:39:48 发布
最新推荐文章于 2024-07-25 12:39:48 发布
阅读量191 收藏
点赞数 2
分类专栏： 【C++ 入门到入土】 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55953229/article/details/138042388
版权

string.h

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




namespace goat
{
	
	//#define NUMS 16
	//char* Buffer[NUMS];
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;



		//迭代器
		iterator begin();

		iterator end();//最后一个数据下一个位置

		void Printf();

		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}
		//构造函数
		//无参
	
		//string()
		//	:_str(new char[1])//char*类型解引用遇到\0才会中止，所以这里不能直接给空指针，这里要给nullptr空指针会直接报错
		//	,_size(0)
		//	,_capacity(0)
		//{
		//	_str[0] = '\0';
		//}


		//有参

		//浅拷贝
		string(const char* str = "");//缺省值为\0因为空字符串默认结尾带\0，所以只有一个空间


		//深拷贝
		//1.
		string(const string& str);
		//2.
		//string(const string& str)
		//{
		//	string tmp(str);
		//	swap(tmp);

		//}


		
		//析构
		~string();

		//clear清理
		void clear();
		
		//[]重载和cons[]重载
		char& operator[](size_t pos);
		char& operator[](size_t pos) const;



		//获取私有成员变量
		size_t size() const;
		size_t capacity() const;
		const char* c_str();
		//resize和reserve
		void reserve(size_t n);
		void resize(size_t n);//没给字符就填空字符\0
		void resize(size_t n, char ch);
		

		//字符插入
		void push_back(char ch);
		void append(const char* ch);
		void append(size_t pos, const char* ch);
		string& insert(size_t pos, char ch);
		string& insert(size_t pos, const char* ch);
		
		

		//字符删除
		void erase(size_t pos, size_t len = npos);

		//swap交换
		void swap(string& str);



		//赋值重载
		//s1 = s2
		string& operator=( string str)
		{
			swap(str);
			return *this;
		}
		
		




		//运算符重载
		string& operator+=(char str)
		{
			push_back(str);
			return *this;
		}

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

		string& operator+=(const string& str)
		{
			append(str._str);
			return *this;
		}
		bool operator <(const string& str1) const
		{
			return strcmp(_str, str1._str) < 0;
		}
		bool operator ==(const string& str1) const
		{
			return strcmp(_str, str1._str) == 0;
		}

		//先实现小于和等于，后面就可以直接复用小于等于函数
		bool operator <=(const string& str1) const
		{
			return *this < str1 || *this == str1;
		}
		bool operator >(const string& str1) const
		{
			return !(*this <= str1);
		}
		bool operator >=(const string& str1) const
		{
			return !(*this < str1);
		}
		bool operator !=(const string& str1) const
		{
			return !(*this == str1);
		}

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

		//截取字符串
		string substr(size_t pos, size_t len = npos);
		
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	public:
		const static size_t npos = -1;

	};
	//const size_t string::npos = ;

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

string.cpp

#include"string.h"


//迭代器实现
goat::string::iterator goat::string::begin()
{
	return _str;
}
goat::string::iterator goat::string::end()//指向最后一个数据下一个位置
{
	return _str + _size;
}

goat::string::const_iterator goat::string::begin() const
{
	return _str;
}
goat::string::const_iterator goat::string::end() const
{
	return _str + _size;
}




void goat::string::Printf()
{
	std::cout << c_str() << std::endl;
	std::cout << std::endl;
}

//构造
//浅拷贝
goat::string::string(const char* str = "")//缺省值为\0因为空字符串默认结尾带\0，所以只有一个空间
	：_size(strlen(str))
	, _capacity(_size)//不带\0
{
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}
//深拷贝
goat::string::string(const string& str)
{
	_str = new char[str._capacity + 1];
	strcpy(_str, str._str);
	_size = str._size;
	_capacity = str._capacity;

}

//析构
goat::string::~string()
{
	delete[] _str;
	_str = nullptr;
	_capacity = _size = 0;
}
//清理
void goat::string::clear()
{
	_str[0] = '\0';
	_size = 0;


}
//[]重载和cons[]重载
char& goat::string::operator[](size_t pos)
{
	assert(pos < _size);

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

	return _str[pos];
}

//获取私有成员变量
size_t goat::string::size() const
{
	return _size;
}
size_t goat::string::capacity() const
{
	return _capacity;
}
const char* goat::string::c_str()
{
	return _str;
}


//resize和热serve
void goat::string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];//可以存n个字符，多开一个空间留给\0
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;

		_capacity = n;

	}
}
void goat::string::resize(size_t n)//没给字符就填空字符\0
{
	if (n <= _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		while (_size < n)
		{
			_str[_size] = '\0';
			++_size;
		}
		_str[_size] = '\0';
	}

}
void goat::string::resize(size_t n, char ch)
{
	if (n <= _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		while (_size < n)
		{
			_str[_size] = ch;//ch有可能是\0有可能不是
			++_size;
		}
		_str[_size] = '\0';
	}
}

void goat::string::push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
		//reserve(_capacity * 2);

	}
	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';
}

void goat::string::append(const char* ch)
{
	size_t size = strlen(ch);
	if (_size + size > _capacity)
	{
		reserve(_size + size);


	}
	strcpy(_str + _size, ch);//strcpy也会拷贝'\0'
	_size += size;
}

void goat::string::append(size_t pos, const char* ch)
{
	assert(pos < _size);

	size_t size = strlen(ch);
	if (_size + size > _capacity)
	{
		reserve(_size + size);


	}
	strcpy(_str + _size, ch);//strcpy也会拷贝'\0'
	_size += size;
}

goat::string& goat::string::insert(size_t pos, char ch)
{
	assert(pos <= _size);

	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);

	}
	//当pos为0时end<0才会结束，这里当pos为-1时“（int）end >= （size_t）pos”会发生整形提升end转换成size_t类型

	//方法一：强转避免提升
	// 
	// size_t end = _size;
	//while (end >= (int)pos)
	//{
	//	_str[end + 1] = _str[end];
	//	--end;
	//}
	//_str[pos] = ch;
	//++_size;

	//方法二：
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
	return *this;

}

goat::string& goat::string::insert(size_t pos, const char* ch)
{
	assert(pos <= _size);
	size_t len = strlen(ch);
	reserve(_size + len);
	size_t end = _size + len + 1;
	while (end < pos)
	{
		_str[end] = _str[end - len];
		--end;
	}

	//插入方法一
	strncpy(_str + pos, ch, len);

	//方法二
	//size_t j = 0;
	//for (size_t i = pos; i < pos + len; i++)
	//{
	//	_str[pos] = ch[j];
	//	j++;
	//}

	_size += len;
	_str[_size] = '\0';

	return *this;

}


//字符删除
void goat::string::erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);

	if (len == npos || len + pos >= _size)
	{
		_str[_size] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;

	}
}

//swap交换
void goat::string::swap(string& str)
{
	std::swap(_str, str._str);
	std::swap(_size, str._size);
	std::swap(_capacity, str._capacity);
}


//赋值重载
//s1 = s2
//方法一
goat::string& goat::string::operator=(string str)
{
	swap(str);
	return *this;
}

//方法二
/*string& operator=(const string& str)
{
	if (this != &str)
	{
		char* tmp = new char[str._capacity + 1];
		strcpy(tmp, str._str);
		delete[] _str;
		_str = tmp;
		_size = str._size;
		_capacity = str._capacity;


	}
	return *this;

}*/
/*string& operator=(const string& s)
{
	char* tmp = new char[s._capacity + 1];
	strcpy(tmp, s._str);
	delete[] _str;
	_str = tmp;
	_size = s._size;
	_capacity = s._capacity;

	return *this;
}*/


//查找
size_t goat::string::find(char ch, size_t pos = 0)
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}
size_t find(const char* ch, size_t pos = 0)
{
	const char* p = strstr(_str, ch);//没找到返回NULL
	if (p)
	{
		return p - _str;
	}
	else
	{
		return npos;
	}

	return npos;
}
goat::string goat::string::substr(size_t pos, size_t len = npos)
{
	string s;
	size_t end = pos + _size;
	if (len == npos || pos + len >= _size)//有多少取多少
	{
		len = _size - pos;
		s.reserve(len);
		for (size_t i = pos; i < end; i++)
		{
			s += _str[i];
		}
	}
	else
	{
		for (size_t i = pos; i < _size + len; i++)
		{
			s += _str[i];
		}
	}
	return s;
}
ostream& goat::operator<<(ostream& out, const string& s)
{
	/*for (size_t i = 0; i < s.size(); i++)
	{
		out << s[i];
	}*/

	for (auto ch : s)
	{
		out << ch;
	}
	return out;
}
istream& goat::operator>>(istream& in, string& s)
{
	//char ch;
	//in >> ch;//流提取遇到空格和换行结束,但是这边cin拿不到空格——scanf和cin把空格和换行作为分隔符所以拿不到
	//while (ch != ' ' && ch != '\n')
	//{
	//	s += ch;
	//	in >> ch;
	//}
	s.clear();
	char ch;
	ch = in.get();//get时,这时就不管是什么字符都会一个一个拿
	while (ch != ' ' && ch != '\n')
	{

		s += ch;
		//in >> ch;
		ch = in.get();
	}
	return in;

}
istream& goat::getline(istream& is, string& str)
{
	str.clear();
	char ch;
	ch = in.get();
	char buff[128];
	size_t i = 0;
	while (ch != '\0')
	{
		buff[i++] = ch;
		if (i == 127)//当buff缓冲区满时，写入数据
		{
			buff[127] = '\0';
			str += buff;
			i = 0;
		}
		ch = in.get();

	}

	if (i > 0)//循环完后buff缓冲区还有数据，补上
	{
		buff[i] = '\0';
		str += buff;
	}
	return in;

}
goat¢
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++实现的任意进制转换（数据结构——栈和队列）
08-10
在实现过程中，可以使用标准库中的`std::stack`和`std::queue`来创建和管理数据结构，`std::stringstream`用于数字和字符串之间的转换，以及`std::pow`来计算基数的幂次。此外，利用C++的模板功能，可以让这个转换...
数据结构学习——我的string类
10-10
在C++编程中，"数据结构学习——我的string类"是一个典型的任务，旨在帮助初学者理解数据结构的基本概念，并通过实现自定义的string类来深化对C++的理解。下面将详细讨论这个主题，以及相关的知识点。 首先，让我们...
C++——string模拟实现
2303_78442132的博客
03-09 1783
C++、string类
C++ —— 模拟实现string类
weixin_59913110的博客
11-07 1192
本篇博客分享了笔者如何模拟实现string类的过程。其中包括最常用、最实用的接口。例如流插入、提取运算符重载、下标运算符重载、常用的构造函数、析构函数……
【C++】——string模拟实现
m0_74092462的博客
05-31 1463
string的模拟实现其实就是增删改查，只不过加入了类的概念。为了防止与std里面的string冲突，所以这里统一用String。目录前言一 初始化和销毁1.1 构造函数1.2 析构函数二 迭代器实现三 容量大小及操作四 运算符重载五 字符串操作5.1 截取操作5.2 查找操作六 流插入流提取七 string与string相加string类模拟实现完整代码总结以上就是string的全部内容了，💞。
C++——string常用接口模拟实现
Britney_dark的博客
08-05 597
愿你被世界以温柔对待。
【C++】STL——string模拟实现
M的博客
06-07 2793
string模拟实现
C++——string类的模拟实现
想要上进的coder的博客
04-05 2269
我们要模仿STL库里面的string，基本实现常用的一些操作 构造函数 string(const char* str = "")//给缺省值""空字符串，就不用写上面那个重载了 :_size(strlen(str)) , _capacity(_size) { _str = new char[_capacity + 1];// +\0 strcpy(_str, str);//char *strcpy( char *strDestination, const char *strSource );
C++STL——string类详解及其模拟实现
Forward♞的博客
11-27 1242
STL全称，译为下面展示STL的六大组件：本章，我们将对string部分常用的功能进行说明和使用，最后对string进行简单的模拟实现本章思维导图：注：本章思维导图已经同步导入至。
【C++】——string的模拟实现
m0_56069910的博客
05-13 1111
【C++】——string的模拟实现
C++ —— string类的实用接口
weixin_59913110的博客
10-28 1148
string类实用的接口，没有废话，代码很多：size()与length()的区别，resize()更改有效字符个数以及对容量的影响；string的遍历方式，[]运算符重载，范围for，迭代器；+=运算符重载，find的使用……未更新完，喜欢就收藏起来！
【C++ —— string类】
qq_55953229的博客
04-19 571
拷贝构造一份str内的字符串 使用在个字符后个长度常量字符串初始化，如果不输入的化，使用缺省值，可以理解为直接从字符串pos位置，直到\0停止。 npos的值是由-1转化正无符号整数，也就是int型最大的整数值： string使用常量字符串初始化 我们在来看以下代码,这个代码也是能够初始化的。 为什么呢？ 这里string有一个带参的构造函数，我们用常量字符串给s2赋值时：1. 先构造了一个string类型的临时对象，传入常量字符串，然后s2再对临时对象拷贝构造。不过这里因为一个构造+拷贝构造被编译器直
模拟即时通信系统.7z
05-11
《构建模拟即时通信系统——基于C++的实现与解析》 即时通信系统，如QQ和微信，已经成为现代人生活中不可或缺的一部分。它们提供了丰富的功能，包括好友管理、群组聊天、消息推送等。本文将深入探讨如何使用C++来...
初学者学习C++ Builder第一个程序（模拟聊天室）v1.11，经典！
11-21
本教程将围绕"初学者学习C++ Builder第一个程序——模拟聊天室"展开，通过构建一个简单的聊天室应用，来介绍C++ Builder的基础知识和GUI编程的基本概念。 首先，让我们了解C++ Builder中的基本元素。在C++ Builder...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1192
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 660
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 272
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1133
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值