容器 string 的模拟实现

news2024/11/14 20:53:26

容器 string 的模拟实现

  • 开篇解释
  • 代码实现：
    • myString.h 头文件
    • myString.cpp 实现文件

模拟实现 string 能对 STL 有更深刻的认识，底层了解越丰富，使用起来越顺手

接下来我会以 .h 头文件以及其 .cpp 的实现文件展示其大致模拟，这只是遵循 STL 的功能来模拟的而已，实际上的细节、效率以及设计方式自然是比不过库里大佬所写的

开篇解释

首先，string 作为一个对象，最主要的属性就是 字符串本身（堆上空间） 、 字符串长度 和 为字符串所开辟出来的空间大小 ：

在这里插入图片描述

这里要注意：

  • _str 是指针， 指向堆上的一块空间 ，字符串就存储在这块空间里
  • 字符串与 C 语言的字符串一样 其末尾均有 '\0' ，别无二致
  • _size 始终指示 字符串的长度 ，随其长度动态变化，不包含 字符串末尾空字符 '\0'
  • _capacity 始终指示 为字符串开辟的空间大小 ，随其长度动态变化， 包含 空间末尾空字符 '\0'
  • 注意：为防止可能的越界 bug ，为字符串开辟的空间末尾始终含有 '\0' ，字符串本身末尾也含有 '\0'

在这里插入图片描述

我这里为字符串实现的扩容没有按照 g++ 或者 vs 约定俗成的 2 倍扩容之类的 ，只是单纯的空间不够就扩容，当然如果想实现，也可以写一个额外的 功能函数 （ 要兼容拼接长字符串 ），只是要注意接口为 private 私有

因为我的类名也是 string ，所以在 myString.h 头文件里 最好标识命名空间 ，我写在了名为 what 的命名空间里

接下来就没什么了，实现代码：

代码实现：

以下代码为 vs2019 测试 ，如有 Bug 欢迎指正 ^ ^

myString.h 头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <assert.h>

namespace what
{
	class string
	{
	public:
		// Constructors: *************************************
		string(const char* pStr = "");
		string(const string& str);

		// Destructor: ****************************************
		~string();

		// operator= ******************************************
		string& operator=(const char* str);
		string& operator=(const string& str);
		string& operator= (char c);

		// Iterators: *****************************************
		typedef char* iterator;
		typedef const char* const_iterator;
		typedef char* reverse_iterator;

		iterator begin();
		const_iterator begin() const;
		iterator end();
		const_iterator end() const;
		reverse_iterator rbegin() const;
		reverse_iterator rend() const;

		// Capacity: ********************************************
		size_t size() const;
		size_t capacity() const;
		void resize(size_t n, char c = '\0');
		void reserve(size_t n = 0);
		void clear();
		bool empty() const;

		// Element access: ***************************************
		char& operator[] (size_t pos);
		const char& operator[] (size_t pos) const;

		// Modifiers: *******************************************
		string& operator+=(const string& str);
		string& operator+=(const char* str);
		string& operator+=(char c);
		string& append(const string& str);
		string& append(const char* str, size_t n);
		// 有了 += 的功能，剩下的 append 很好实现，自己试试咯
		void push_back(char c);
		void swap(string& str);
		string& insert(size_t pos, const string& str);
		string& erase(size_t pos = 0, size_t len = npos);

		// String operations: ************************************
		const char* c_str() const;
		const char* data() const;
		size_t copy(char* s, size_t len, size_t pos = 0) const;
		size_t find(char c, size_t pos = 0) const;
		size_t find(const char* s, size_t pos = 0) const;
		string substr(size_t pos = 0, size_t len = npos) const;

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	public:
		static const size_t npos;
	};

	// Non-member function overloads: *******************************************
	string operator+(const string& lhs, const string& rhs);
	bool operator==(const string& lhs, const string& rhs);
	bool operator!=(const string& lhs, const string& rhs);
	bool operator<(const string& lhs, const string& rhs);
	bool operator<=(const string& lhs, const string& rhs);
	bool operator>(const string& lhs, const string& rhs);
	bool operator>=(const string& lhs, const string& rhs);
	void swap(string& x, string& y);
	std::istream& operator>>(std::istream& is, string& str);
	std::ostream& operator<<(std::ostream& os, const string& str);
	std::istream& getline(std::istream& is, string& str, char delim = '\n');
}

myString.cpp 实现文件



#include "myString.h"

const size_t what::string::npos = -1;

what::string::string(const char* pStr)
{
	_size = strlen(pStr);
	_capacity = _size + 2;
	_str = new char[_capacity];
	strcpy(_str, pStr);
	_str[_capacity - 1] = '\0';
}

what::string::string(const string& str)
	: _size(strlen(str._str))
{
	_capacity = _size + 2;
	_str = new char[_capacity];
	strcpy(_str, str._str);
	_str[_capacity - 1] = '\0';
}
// 拷贝构造的现代写法
//what::string::string(const string& str)
//{
//	string tmp(str.c_str());
//	swap(tmp);
//}

// Destructor: ****************************************
what::string::~string()
{
	delete[] _str;
	_size = _capacity = 0;
}

// operator= ******************************************
what::string& what::string::operator=(const char* str)
{
	_size = strlen(str);
	if (_capacity - 1 < _size + 1)
	{
		_capacity = _size + 2;
		char* tmp = new char[_capacity];
		strcpy(tmp, str);
		delete[] _str;
		_str = tmp;
		_str[_capacity - 1] = '\0';
	}
	else
		strcpy(_str, str);
	return *this;
}

what::string& what::string::operator=(const string& str)
{
	_size = str._size;
	if (_capacity - 1 < _size + 1)
	{
		_capacity = _size + 2;
		char* tmp = new char[_capacity];
		strcpy(tmp, str._str);
		delete[] _str;
		_str = tmp;
		_str[_capacity - 1] = '\0';
	}
	else
		strcpy(_str, str._str);
	return *this;
}
// 赋值重载的现代写法
//what::string& what::string::operator=(string str)
//{
//	swap(str);
//	return *this;
//}

what::string& what::string::operator= (char c)
{
	delete[] _str;
	_size = 1;
	_capacity = _size + 2;
	_str = new char[_capacity];
	_str[0] = c;
	_str[_size] = '\0';
	_str[_capacity - 1] = '\0';
	return *this;
}

// Iterators: *****************************************
typedef char* iterator;
typedef const char* const_iterator;
typedef char* reverse_iterator;

iterator what::string::begin()
{
	return _str;
}
const_iterator what::string::begin() const
{
	return _str;
}

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

reverse_iterator what::string::rbegin() const
{
	return _str + _size - 1;
}

reverse_iterator what::string::rend() const
{
	return _str - 1;
}

// Capacity: ********************************************
size_t what::string::size() const
{
	return _size;
}

size_t what::string::capacity() const
{
	return _capacity;
}

void what::string::resize(size_t n, char c)
{
	if (n > _size)
	{
		if (n > _capacity - 2)
			reserve(n);
		for (size_t i = _size; i < n; ++i)
			_str[i] = c;
	}
	_size = n;
	_str[_size] = '\0';
}

void what::string::reserve(size_t n)
{
	if (n > _capacity - 2)
	{
		_capacity = n + 2;
		char* tmp = new char[_capacity];
		strcpy(tmp, _str);
		delete _str;
		_str = tmp;
		_str[_capacity - 1] = '\0';
	}
}

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

bool what::string::empty() const
{
	return _size == 0;
}


// Element access: ***************************************
char& what::string::operator[] (size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}
const char& what::string::operator[] (size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

// Modifiers: *******************************************
what::string& what::string::operator+=(const what::string& str)
{
	size_t totalSize = _size + str._size;
	if (_capacity - 1 < totalSize + 1)
		reserve(totalSize);
	size_t k = 0;
	for (size_t i = _size; i < totalSize; ++i)
		_str[i] = str._str[k++];
	_size = totalSize;
	_str[_size] = '\0';
	return *this;
}

what::string& what::string::operator+=(const char* str)
{
	size_t totalSize = _size + strlen(str);
	if (_capacity - 1 < totalSize + 1)
		reserve(totalSize);
	size_t k = 0;
	for (size_t i = _size; i < totalSize; ++i)
		_str[i] = str[k++];
	_size = totalSize;
	_str[_size] = '\0';
	return *this;
}

what::string& what::string::operator+=(char c)
{
	size_t totalSize = _size + 1;
	if (_capacity - 1 < totalSize + 1)
		reserve(totalSize);
	_str[_size] = c;
	_size = totalSize;
	_str[_size] = '\0';
	return *this;
}

what::string& what::string::append(const what::string& str)
{
	*this += str;
	return *this;
}

what::string& what::string::append(const char* str, size_t n)
{
	assert(n <= strlen(str));
	for (size_t i = 0; i < n; ++i)
		*this += str[i];
	*this += '\0';
	return *this;
}
// 有了 += 的功能，剩下的 append 很好实现，自己试试咯

void what::string::push_back(char c)
{
	*this += c;
}

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

what::string& what::string::insert(size_t pos, const what::string& str)
{
	assert(pos <= _size);
	size_t len = strlen(str._str);
	if (_capacity - 1 < _size + len + 1)
		reserve(_size + len + 2);
	for (size_t end = _size + len; end > pos + len - 1; --end)
		_str[end] = _str[end - len];
	strncpy(_str + pos, str._str, len);
	_size += len;
	return *this;
}

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

// String operations: ************************************
const char* what::string::c_str() const
{
	return _str;
}

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

size_t what::string::copy(char* s, size_t len, size_t pos) const
{
	assert(pos < _size);
	if (len + pos >= _size)
	{
		strncpy(s, _str + pos, _size - pos);
		return _size - pos;
	}
	else
	{
		strncpy(s, _str + pos, len);
		return len;
	}
}

size_t what::string::find(char c, size_t pos) const
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; ++i)
		if (_str[i] == c)
			return i;
	return npos;
}

size_t what::string::find(const char* s, size_t pos) const
{
	assert(pos < _size);
	const char* p = strstr(_str + pos, s);
	if (p)
		return p - _str;
	else
		return npos;
}

what::string what::string::substr(size_t pos, size_t len) const
{
	assert(pos < _size);
	char buff[128];
	string tmp;
	buff[127] = '\0';
	if (len >= _size - pos)
	{
		while (true)
		{
			size_t num = copy(buff, 127, pos);
			if (num != 127)
			{
				buff[num] = '\0';
				tmp += buff;
				break;
			}
			else
			{
				pos += 127;
				tmp += buff;
			}
		}
	}
	else
	{
		while (true)
		{
			if (len >= 127)
			{
				size_t num = copy(buff, 127, pos);
				tmp += buff;
				pos += 127;
				len -= 127;
			}
			else
			{
				size_t num = copy(buff, len, pos);
				buff[len] = '\0';
				tmp += buff;
				break;
			}
		}
	}
	return tmp;
}

// Non-member function overloads: *******************************************
what::string what::operator+(const what::string& lhs, const what::string& rhs)
{
	what::string ret;
	ret += lhs;
	ret += rhs;
	return ret;
}

bool what::operator==(const what::string& lhs, const what::string& rhs)
{
	int ret = strcmp(lhs.c_str(), rhs.c_str());
	return ret == 0;
}
bool what::operator!=(const what::string& lhs, const what::string& rhs)
{
	return !(lhs == rhs);
}
bool what::operator<(const what::string& lhs, const what::string& rhs)
{
	int ret = strcmp(lhs.c_str(), rhs.c_str());
	return ret < 0;
}
bool what::operator<=(const what::string& lhs, const what::string& rhs)
{
	return (lhs < rhs) || (lhs == rhs);
}
bool what::operator>(const what::string& lhs, const what::string& rhs)
{
	return !(lhs <= rhs);
}
bool what::operator>=(const what::string& lhs, const what::string& rhs)
{
	return !(lhs < rhs);
}

void what::swap(what::string& x, what::string& y)
{
	x.swap(y);
}

std::istream& what::operator>>(std::istream& is, what::string& str)
{
	str.clear();
	size_t i = 0;
	char c = '\0';
	char buff[128] = { 0 };
	c = is.get();
	while (c != ' ' && c != '\n')
	{
		buff[i++] = c;
		if (i == 127)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}
		c = is.get();
	}
	if (i > 0)
	{
		buff[i] = '\0';
		str += buff;
	}
	return is;
}

std::ostream& what::operator<<(std::ostream& os, const what::string& str)
{
	os << str.c_str();
	return os;
}

std::istream& what::getline(std::istream& is, what::string& str, char delim)
{
	str.clear();
	size_t i = 0;
	char c = '\0';
	char buff[128] = { 0 };
	c = is.get();
	while (c != delim)
	{
		buff[i++] = c;
		if (i == 127)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}
		c = is.get();
	}
	if (i > 0)
	{
		buff[i] = '\0';
		str += buff;
	}
	return is;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1950364.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【代码】Python3｜Scrapy框架初探（汽车之家大连市二手车车辆数据爬取、清洗与可视化）

【代码】Python3｜Scrapy框架初探（汽车之家大连市二手车车辆数据爬取、清洗与可视化）

本篇主要是整个项目的介绍&#xff0c;没提到太多琐碎的技术细节&#xff0c;以后有空的话会整理一下 Scrapy 和原生爬虫的差异&#xff0c;还有它坑人的一些地方&#xff0c;单发出来。 开源地址&#xff1a;https://github.com/shandianchengzi/car_home_spider 使用说明&a…
阅读更多...
学习日记：数据类型2

学习日记：数据类型2

目录 1.转义字符 2.隐式类型转换 2.1 强制类型转换 2.2 不同类型间赋值 3.运算符 表达式 3.1 算术运算符 3.2 算术运算优先级 3.3 赋值运算 3.3.1 不同类型间混合赋值 3.4 逗号运算 4.生成随机数 5. 每日一练 1.转义字符 \n 表示换行 \t …
阅读更多...
Vue3可媲美Element Plus Tree组件实战之移除节点

Vue3可媲美Element Plus Tree组件实战之移除节点

Element Plus Tree自定义节点内容示例中介绍了移除节点的用法&#xff0c;个人觉得作为提供给用户API&#xff0c;应该遵循迪米特法则&#xff0c;把功能实现的细节封装在组件内部&#xff0c;而提供给用户最简单的操作方式&#xff0c;同时在此基础上支持用户的扩展。 因此&a…
阅读更多...
ITK-中值滤波

ITK-中值滤波

作者&#xff1a;翟天保Steven 版权声明&#xff1a;著作权归作者所有&#xff0c;商业转载请联系作者获得授权&#xff0c;非商业转载请注明出处 中值滤波原理 中值滤波是一种常用的非线性滤波技术&#xff0c;用于去除图像中的噪声&#xff0c;特别是椒盐噪声和脉冲噪声。它…
阅读更多...
MM 7 -采购- 询报价

MM 7 -采购- 询报价

思维导图 说明 sap提供了 询价 报价和比价的功能。 不建议在sap管理。一般引导不在sap管理。 流程&#xff1a; 操作 询价 ME41 报价ME47 比价ME49 拒绝 对于不符合条件的报价进行拒绝 生成信息记录 后台表 Ekko ekpo 。采购凭证类别&#xff1a;A
阅读更多...
csa笔记6-网络管理命令

csa笔记6-网络管理命令

nmcli命令 字符终端&#xff0c;可以立即生效且重启系统后配置也不会丢失 nmtui命令 可视终端&#xff0c;立即生效&#xff0c;重启有效 network.service 管理网络 RHEL 7 以前&#xff1a;使用network.service管理网络 RHEL 7&#xff1a;使用network.service和Netwo…
阅读更多...
Docker(十一)-Docker运行nginx1.10容器实例

Docker(十一)-Docker运行nginx1.10容器实例

1.下载镜像 docker pull nginx:1.102.直接启动实例(目的&#xff1a;复制出配置文件) 2.1启动实例 docker run -d -p 80:80 --namenginx1.10 nginx:1.102.2将容器内文件拷贝到本地目录 docker cp nginx1.10:/etc/nginx /software/nginx/将/software/nginx/nginx目录改为/so…
阅读更多...
07 JSP

07 JSP

文章目录 JSP1、JSP 概述2、JSP 脚本和缺点3、EL 表达式4、JSTL标签5、MVC模式和三层架构6、案例 JSP 1、JSP 概述 JSP&#xff08;全称&#xff1a;Java Server Pages&#xff09;&#xff1a;Java 服务端页面 &#xff08;1&#xff09;是一种动态的网页技术 &#xff08;2&…
阅读更多...
11 逻辑运算符

11 逻辑运算符

逻辑运算符 and、or、not 常用来连接条件表达式构成更加复杂的条件表达式&#xff0c;并且 and 和 or 具有惰性求值或逻辑短路的特点&#xff0c;当连接多个表达式时只计算必须要计算的值。 运算符 and 和 or 并不一定会返回 True 或 False &#xff0c;而是得到最后一个被计算…
阅读更多...
WordPress主题追格企业官网主题免费开源版V1.1.6

WordPress主题追格企业官网主题免费开源版V1.1.6

追格企业官网主题免费开源版由追格开发的一款开源wordpress主题&#xff0c;专为企业建站和追格企业官网小程序&#xff08;开源版&#xff09;PC配套而设计&#xff0c;功能集新闻动态、留言反馈、产品与服务、公司简介、联系我们等模块。
阅读更多...
【MySQL进阶篇】锁：全局锁、表级锁以及行级锁

【MySQL进阶篇】锁：全局锁、表级锁以及行级锁

一、锁的概述 锁是计算机协调多个进程或线程并发访问某一资源的机制。在数据库中除传统的计算资源&#xff08;CPU、RAM、I/O&#xff09;的争用以外&#xff0c;数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性、有效性是所有数据库必须要解决的一个问题&am…
阅读更多...
Apache Doris + Paimon 快速搭建指南｜Lakehouse 使用手册（二）

Apache Doris + Paimon 快速搭建指南｜Lakehouse 使用手册（二）

湖仓一体&#xff08;Data Lakehouse&#xff09;融合了数据仓库的高性能、实时性以及数据湖的低成本、灵活性等优势&#xff0c;帮助用户更加便捷地满足各种数据处理分析的需求。在过去多个版本中&#xff0c;Apache Doris 持续加深与数据湖的融合&#xff0c;已演进出一套成熟…
阅读更多...
java学习--枚举

java学习--枚举

问题引入&#xff1a; 当需要解决一个季节类的问题&#xff0c;我们使用学到的类与对象&#xff0c;创建一个季节的类然后添加构造器在进行分装就可以实现&#xff0c;但问题也随之而来&#xff0c;这样不仅可以有正常的四季还可以添加其他不存在的四季以及可以更改四季的属性…
阅读更多...
ElasticSearch学习篇15_《检索技术核心20讲》进阶篇之TopK检索

ElasticSearch学习篇15_《检索技术核心20讲》进阶篇之TopK检索

背景 学习极客实践课程《检索技术核心20讲》https://time.geekbang.org/column/article/215243&#xff0c;文档形式记录笔记。 相关问题&#xff1a; ES全文检索是如何进行相关性打分的&#xff1f;ES中计算相关性得分的时机?如何加速TopK检索&#xff1f;三种思路 精准To…
阅读更多...
广州数据中心机房服务器搬迁规划原则

广州数据中心机房服务器搬迁规划原则

数据中心机房搬迁&#xff0c;需要各个技术团队的紧密配合&#xff0c;制定详细周密的搬迁方案和实施流程&#xff0c;分批实施。作为华南地区主流的数据中心服务商&#xff0c;友力科技&#xff08;广州&#xff09;有限公司&#xff0c;专注数据中心机房服务器搬迁&#xff0…
阅读更多...
[数据集][目标检测]蝗虫检测数据集VOC+YOLO格式1501张1类别

[数据集][目标检测]蝗虫检测数据集VOC+YOLO格式1501张1类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;1501 标注数量(xml文件个数)&#xff1a;1501 标注数量(txt文件个数)&#xff1a;1501 标注…
阅读更多...
Python服务器和客户端功能库之websockets使用详解

Python服务器和客户端功能库之websockets使用详解

概要 WebSockets 是一种在单个 TCP 连接上进行全双工通信的协议&#xff0c;特别适用于需要低延迟和高频率数据传输的实时应用&#xff0c;例如在线游戏、聊天应用和实时数据流。websockets 是一个基于 asyncio 的 Python 库&#xff0c;旨在提供简单易用的 WebSockets 服务器…
阅读更多...
Linux进程信号详解【下】

Linux进程信号详解【下】

&#x1f30e; Linux进程信号详【下】 文章目录&#xff1a; Linux信号详解 核心转储 信号保存       信号的三种状态       信号集操作函数         sigset_t类型接口         sigprocmask接口         sigpending接口         …
阅读更多...
会员信息管理系统-计算机毕业设计源码38258

会员信息管理系统-计算机毕业设计源码38258

目 录 摘要 1 绪论 1.1 研究背景 1.2 研究意义 1.3开发技术 1.3.1 Spring Boot框架 1.3.2 Java语言 1.3.3 MySQL数据库 1.4论文结构与章节安排 2系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1 登录流程 2.2.2数据删除流程 2.3 系统功能分析 2.4 系统用例分析…
阅读更多...
我的世界！

我的世界！

每位冒险家在《我的世界》中的出生点都各不相同&#xff0c; 有的出生在桦木森林&#xff0c;有的出生在草原&#xff0c; 还有的出生在临近海洋的沙滩。 这些环境叫做生物群系&#xff0c;也常被称为生态系统。 在《我的世界》中的不同生物群系具有不同的地域特色—— 不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023