string类的模拟实现

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

上一篇博客我们对string类函数进行了讲解,今天我们就对string类进行模拟实现,以便于大家更加深入地了解string类函数的应用

由于C++的库里面本身就有一个string类,所以我们为了不让编译器混淆视听,我们可以首先将我们自己模拟实现的string类放入一个我们自己定义的命名空间内,这里我将命名空间命名为jh(本人名字首字母缩写):

namespace jh
{
	class string
	{

	};
}

然后就是我们将string类的类的成员进行定义:
string类实际就是字符串,它的几个成员有capacity(容量),size(字符拆串当前字符个数),str(字符串的指针)

namespace jh
{
	class string
	{
	private:
		size_t _capacity;
		size_t _size;
		char* _str;
	};
}

下面我们就对string类的大部分经常使用的成员函数进行模拟实现:

构造函数

首先定义一个构造函数,用于创建string类,这里大家用到了strlen和strcpy函数,所以要带上头文件string.h
还有一个需要注意的点:
这里为_str开辟空间我们需要开辟capacity+1个字符的空间,因为要为\0预留一个字符的空间

string(const char* str = "")
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}
拷贝构造函数

string类的拷贝构造函数也很简单:
和构造函数差不多

string(const string& s)
{
	_str = new char[s._capacity + 1];
	_size = s._size;
	_capacity = s._capacity;
	strcpy(_str, s._str);
}
析构函数

析构函数也很简单,直接将size和capacity置零,指针置为空,将str的空间用delete删除,记得带上[],方便通用语字符和字符串

~string()
{
	delete[] _str;
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}
赋值操作符重载

赋值操作符是一个很常用的操作符,我们的前提两个字符串不相等,如果相等就没必要进行操作,直接返回*this
不相等的情况下我们首先开辟一个tmp的空间将字符串拷贝进去,将tmp赋予_str,然后将size和capacity赋值,这样就完成了赋值操作符的重载

string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		_str = tmp;
		_capacity = s._capacity;
		_size = s._size;
	}
	return *this;
}
返回字符串函数

很简单,但是要记得在函数前加上const修饰函数返回值,函数后加上const修饰_str,避免权限的放大

const char* c_str() const
{
	return _str;
}
返回size函数

同样很简单,返回_size,加上const避免权限的放大

size_t size() const
{
	return _size;
}
下标访问符号重载

下标访问在字符串中很常用,我们需要将其进行断言,如果pos大于size就毫无意义,需要注意的就是带上const,避免权限的放大

const char& operator[](size_t pos)const
{
	assert(pos <= _size);
	return _str[pos];
}
char& operator[](size_t pos)
{
	assert(pos <= _size);
	return _str[pos];
}
迭代器

迭代器主要分为const和非const
我们用typedef将char*命名为iterator
begin函数就直接返回_str
end函数就直接返回 str+size

typedef char* iterator;
typedef const char* const_iterator;

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

const_iterator begin() const
{
	return _str;
}

const_iterator end() const
{
	return _str + _size;
}
reserve函数

reserve函数是一个扩容函数,但是他只是改变capacity,不会改变size,并且不会缩容,缩容很是麻烦,所以只有当n>capacity时才会进行扩容

void reserve(size_t n)
{
	if(n>_capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}
resize函数

resize函数和reserve函数的区别就是resize改变capacity的同时也会改变size,但是当n时小于等于size的时候不会缩容,但是\0的位置被放到了n位置
当size小于n的时候我们就需要把后面的n-size个位置的元素置为ch(\0),同时size也进行改变

void resize(size_t n, char ch = '\0')
{
	if (n <= _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		while (_size < n)
		{
			_str[_size] = ch;
			_size++;
		}
		_str[_size] = '\0';
	}
}
追加函数

追加函数分为两种,一种是追加字符的pushback,一种时追加字符串的append,我们要注意append加上const,避免权限的放大,当追加后容量不够我们就要进行扩容

void pushback(char ch)
{
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
}
void append(const char* str)
{
	size_t len = strlen(str);
	if (len > +_size > _capacity)
	{
		reserve(_capacity+len);
	}
	strcpy(_str + _size, str);
	_size += len;
}
+=操作符重载

这个我们就可以复用pushback和append

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

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

同样的find函数分为字符串和字符类型
这里的pos就用到缺省值,没有给就是0,找不到就是返回-1,也就是通常所说的npos

size_t find(char ch, size_t pos = 0)
		{
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}

			return npos;
		}

		size_t find(const char* sub, size_t pos = 0)
		{
			const char* p = strstr(_str + pos, sub);
			if (p)
			{
				return p - _str;
			}
			else
			{
				return npos;
			}
		}
substr函数

substr函数时去字符串
它有两个参数,一个是pos一个是len,表示从pos位置开始取len长度的字符串,当len+pos大于字符串长度时有多少取多少,开辟空间进行追加即可
npos就是-1,给了默认缺省值

string substr(size_t pos, size_t len = npos)
		{
			string s;
			size_t end = pos + len;
			if (len == npos || pos + len >= _size) // 有多少取多少
 			{
				len = _size - pos;
				end = _size;
			}

			s.reserve(len);
			for (size_t i = pos; i < end; i++)
			{
				s += _str[i];
			}
			return s;
		}
insert函数

insert函数也同样分为插入字符串和插入字符,第一步就是进行断言,如果插入位置pos是大于等于size,那么就毫无意义
当size和capacity已经相等时就需要扩容,为了减少扩容,所以我们一次性扩容两倍
当size加上插入字符串长度len大于capacity时,我们也需要扩容,直接扩容size+len即可,这里我为了方便大家的理解画一张图:
大家可以根据数据结构的知识构思一下我所说的bug
string类的模拟实现,c++,算法,c++,开发语言,数据结构
并且在字符串插入我们要用strncpy,而不是strcpy,因为strcpy时遇到\0才终止拷贝字符串,但是我们这里拷贝字符串不需要把\0拷进去,考进去的话会引发错误,所以我们要用ncpy来拷贝len个字符,不包括\0

void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
}
void insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	size_t end = _size;
	while (end >= pos)
	{
		_str[end + len] = _str[end];
		end--;
	}
	strncpy(_str + pos, str, len);
	_size += len;
}
erase函数

首先要做的还是断言,pos是要小于size的
当长度len时负数时或者pos+len大于等于size时,有多少删除多少,直接将pos位置置为\0
当长度足够时,我们就需要将pos+len后面的字符移动到pos到pos+len的区间内来:
请看图:
string类的模拟实现,c++,算法,c++,开发语言,数据结构

void erase(size_t pos, size_t len = -1)
{
	assert(pos < _size);
	if (len == -1 || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		size_t begin = pos + len;
		while (begin <= _size)
		{
			_str[begin - len] = _str[begin];
			begin++;
		}
		_size -= len;
	}
操作符重载

操作符重载很简单,我们用strcmp函数,并且可以进行复用

bool operator<(const string& s) const
		{
			return strcmp(_str, s._str) < 0;
		}

		bool operator==(const string& s) const
		{
			return strcmp(_str, s._str) == 0;
		}

		bool operator<=(const string& s) const
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s) const
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s) const
		{
			return !(*this < s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}
clear函数

直接将0位置置为\0,同时size置0

void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
流插入和流提取

流插入和提取要放到模拟实现string类的外面,但是要放入命名空间jh内
流插入很简单,直接用语法糖

ostream& operator<<(ostream& out, const string& s)
{
	for (auto ch : s)
		out << ch;

	return out;
}

流提取就需要理解透彻一点:
首先提取时我们会有一个缓冲区,所以我们每次提取之前需要用clear清理一次缓冲区
其次为了减少扩容,我们适当地开辟空间,等到该空间满了直接用+=赋予字符串s
这里需要用get函数来提取字符
然后用while循环,当当前位置的字符ch不等于空格并且不等于换行符时才能放入开辟好的buff空间里,当i等于128时,我们将i位置置为\0,将buff空间存储的字符串用+=放入string类对象s,同时i置为0,再进行一次get提取,判断输入的in对象是否还有(例如:输入xy yz,如果不用whie循环的条件和再次get的话,xy yz就只能提取xy)
当i不等于0时我们也需要将i位置置为\0,并且将buff+=给s

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

好了,今天的分享到这里就结束了,感谢大家的支持!

完整代码如下:文章来源地址https://www.toymoban.com/news/detail-811999.html

#include<iostream>
#include<assert.h>
using namespace std;
namespace jh
{
	class string
	{
	public:
		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		string(const string& s)
		{
			_str = new char[s._capacity + 1];
			_size = s._size;
			_capacity = s._capacity;
			strcpy(_str, s._str);
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);
				_str = tmp;
				_capacity = s._capacity;
				_size = s._size;
			}
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
		size_t size() const
		{
			return _size;
		}
		const char& operator[](size_t pos)const
		{
			assert(pos <= _size);
			return _str[pos];
		}
		char& operator[](size_t pos)
		{
			assert(pos <= _size);

			return _str[pos];
		}
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}
		
		void reserve(size_t n)
		{
			if(n>_capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (len > +_size > _capacity)
			{
				reserve(_capacity+len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}
		void resize(size_t n, char ch = '\0')
		{
			if (n <= _size)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				while (_size < n)
				{
					_str[_size] = ch;
					_size++;
				}
				_str[_size] = '\0';
			}
		}
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		size_t find(char ch,size_t pos=0)
		{
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
					return i;
			}
			return -1;
		}
		size_t find(const char* str, size_t pos = 0)\
		{
			char* p = strstr(_str+pos, str);
			if (p)
			{
				return p - _str;
			}
			else
			{
				return -1;
			}
		}
		string substr(size_t pos, size_t len=-1)
		{
			string s;
			size_t end = pos + len;
			if (len == -1 || pos+len >= _size)
			{
				len = _size - pos;
				end = _size;
			}
			s.reserve(len);
			for (size_t i = pos; i < end; i++)
			{
				s += _str[i];
			}
			return s;
		}
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = ch;
			_size++;
		}
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			size_t end = _size;
			while (end >= pos)
			{
				_str[end + len] = _str[end];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}
		void erase(size_t pos, size_t len = -1)
		{
			assert(pos < _size);
			if (len == -1 || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t begin = pos + len;
				while (begin <= _size)
				{
					_str[begin - len] = _str[begin];
					begin++;
				}
				_size -= len;
			}
		}
		bool operator<(const string& s) const
		{
			return strcmp(_str, s._str) < 0;
		}

		bool operator==(const string& s) const
		{
			return strcmp(_str, s._str) == 0;
		}

		bool operator<=(const string& s) const
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s) const
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s) const
		{
			return !(*this < s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}

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

	private:
		size_t _capacity;
		size_t _size;
		char* _str;
	public:
		const static size_t npos;
	};
	const size_t string::npos = -1;
	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
			out << ch;

		return out;
	}

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

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

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

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

相关文章

  • 【C++初阶】9. string类的模拟实现

    string类的完整实现放这里啦!快来看看吧 string类的作用就是将字符串类型实现更多功能,运算符重载,增删改查等等操作,所以其成员就包含char*的字符串 在之前的学习过程中,我们了解到类中存在的六个默认函数,其中就包含默认构造函数,那么对于string类是否需要用户自

    2024年02月09日
    浏览(34)
  • 【c++】string类的使用及模拟实现

    我们先了解一下什么是OOP思想 OOP思想,即面向对象编程(Object-Oriented Programming)的核心思想,主要包括“抽象”、“封装”、“继承”和“多态”四个方面。 抽象:抽象是忽略一个主题中与当前目标无关的那些方面,以便充分地注意与当前目标有关的方面。抽象并不打算了

    2024年04月11日
    浏览(34)
  • 【C++初阶】学习string类的模拟实现

    前面已经学习了string类的用法,这篇文章将更深入的学习string类,了解string类的底层是怎么实现的。当然,这里只是模拟一些常用的,不常用的可以看文档学习。 我们一共创建两个文件,一个是test.cpp文件,用于测试;另一个是string.h文件,用于声明和定义要模拟的string类。

    2024年02月03日
    浏览(52)
  • 【C++初阶】第八站:string类的模拟实现

    目录 string类的模拟实现 经典的string类问题 浅拷贝 深拷贝 写时拷贝(了解) 构造函数 string的全缺省的构造函数: string的拷贝构造函数 传统写法 现代写法 string的赋值重载函数 传统写法 现代写法 string的无参构造函数: 遍历函数 operator[ ] 迭代器 迭代器的底层实现begin和end:

    2024年04月28日
    浏览(39)
  • STL中的string类的模拟实现【C++】

    构造函数设置为缺省参数,若不传入参数,则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度(不包括’\\0’) 在模拟实现拷贝构造函数前,我们应该首先了解深浅拷贝: 浅拷贝:拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一

    2024年02月15日
    浏览(39)
  • 【C++】深度剖析string类的底层结构及其模拟实现

    在上两篇中,我们已经学习了string类的一个使用,并且做了一些相关的OJ练习,相信大家现在对于string的使用已经没什么问题了。 那我们这篇文章呢,就来带大家对string进行一个模拟实现,这篇文章过后,有些地方大家或许就可以理解的更深刻一点。 那通过之前文章的学习我

    2023年04月17日
    浏览(103)
  • 【C++初阶】STL详解(二)string类的模拟实现

    本专栏内容为:C++学习专栏,分为初阶和进阶两部分。 通过本专栏的深入学习,你可以了解并掌握C++。 💓博主csdn个人主页:小小unicorn ⏩专栏分类:C++ 🚚代码仓库:小小unicorn的代码仓库🚚 🌹🌹🌹关注我带你学习编程知识 注:为了防止与标准库当中的string类产生命名冲

    2024年02月05日
    浏览(54)
  • 【C++练级之路】【Lv.6】【STL】string类的模拟实现

    欢迎各位小伙伴关注我的专栏,和我一起系统学习C语言,共同探讨和进步哦! 学习专栏 : 《进击的C++》 关于 STL容器 的学习,我会采用 模拟实现 的方式,以此来更加清楚地了解其 底层原理和整体架构 。而string类更是有100多个接口函数,所以模拟实现的时候只会调重点和

    2024年01月18日
    浏览(46)
  • [C++] string类的介绍与构造的模拟实现,进来看吧,里面有空调

    C语言中,字符串是以’\\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合面向对象的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 因此C++中,为了让我们更简单、方便

    2024年02月12日
    浏览(38)
  • 【C++】:STL中的string类的增删查改的底层模拟实现

    本篇博客仅仅实现存储字符(串)的string 同时由于C++string库设计的不合理,我仅实现一些最常见的增删查改接口 接下来给出的接口都是基于以下框架: C++string标准库中,无参构造并不是空间为0,直接置为空指针 而是开一个字节,并存放‘\\0’ C++中支持无参构造一个对象后,直

    2024年02月05日
    浏览(51)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包