容器 string 的模拟实现

最新推荐文章于 2024-10-01 05:07:35 发布
最新推荐文章于 2024-10-01 05:07:35 发布
阅读量393 收藏 6
点赞数 3
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77289177/article/details/140707832
版权

容器 string 的模拟实现

模拟实现 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;
}
溢檀香
关注
专栏目录
STL库string类的模拟实现
02-28
1. 字符串是表示字符序列的类 2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于...2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
使用Java自定义注解模拟实现SpringBoot相关注解.zip
04-07
本教程将探讨如何使用Java自定义注解来模拟实现这些SpringBoot相关的注解功能。 首先，我们来看`@Autowired`注解。`@Autowired`是Spring框架中的一个关键注解，用于自动装配bean。当我们想在类中注入某个依赖时，而...
简单的servlet容器实现
08-23
在本示例中，我们看到一个简化的Servlet容器的实现，这个容器仅用于理解基本概念，而非生产环境中的实际应用。 首先，让我们分析代码结构。`HttpServer1` 类是一个基础的服务器端点，它监听指定的端口（在这个例子...
使用Java注解模拟spring ioc容器过程解析
08-18
通过使用Java注解，我们可以模拟Spring IOC容器的过程，实现依赖注入和控制反转。 在下面的示例代码中，我们将使用Java注解来模拟Spring IOC容器的过程。首先，我们定义了两个注解：Component和Value。Component...
JS模拟浏览器实现全局搜索功能
11-30
在JavaScript中，模拟浏览器的全局搜索功能涉及到网页内容的检索、匹配和高亮显示。以下是一些关键知识点的详细说明： 1. **选取指定模块内容**： 使用`document.querySelector()`或`document.querySelectorAll()`...
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1102
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 644
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 412
【代码】求n的阶乘的相反数（c语言）
简易STL实现 | Set 的实现
AsherGu的博客
09-26 443
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 643
【C++】stack和queue的使用及注意事项
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 305
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
最新发布
Ddddddd_158的博客
10-01 255
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
C/C++语言基础--C++运算符重载以及其重载限制
weixin_74085818的博客
09-27 987
运算符重载，就是赋予运算符新的含义。它是重载系统内部运算符的函数，是实现类静态多态性的方式之一。它本质上是函数重载。// 假设都属于学生类// 想要对比谁的年龄大，试想一下，能不能像正常比较大小那样直接比较呢？答案当然是可以的，这个就是我们这节课要学习的**“运算符重载”**，这样进行重载后，类更像是一种自定义数据类型。实际上，我们已经在不知不觉之中使用了运算符重载。列如：我们习惯使用的对整数，浮点数运用+、-、*、/，其实计算机对整数和浮点数的操作过程是不一样的，这个主要是整数和浮点数的。
C++基础知识十
2302_80378107的博客
09-28 722
在一个string类型的字符后面插入其它的字符可以用push_back和append，这俩个是常用的。使用push_back需要注意的是参数是char型的，所以要用‘’，且里面是单个字符，不能是字符串。使用append函数时参数就是字符串用”“符号。
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 786
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
C--结构体和位段的使用方法
一年，我很需要这一年
09-26 1475
C--结构体和位段的使用方法
c++ day06
yangh1231的博客
09-25 353
【代码】c++ day06。
C++：STL（四）之vector的基本介绍与使用方式|容器接口
白乐天_ξ( ✿＞◡❛)的博客
09-28 1171
本文主要是介绍vector容器以及接口的使用方式，和string类的那一节相似！
set和map
2302_79795489的博客
09-26 215
在 C++ 中，set和map是两个常用的容器，它们分别在<set>和<map>头文件中定义。
C++自定义实现string类
通过模拟实现`std::string`，开发者可以更好地理解字符串类的工作原理，这对于深入学习C++和理解STL容器至关重要。同时，这个过程也有助于提高编程技能，因为需要处理内存管理和复杂的数据结构操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值