模拟实现String

最新推荐文章于 2022-12-11 17:37:47 发布
最新推荐文章于 2022-12-11 17:37:47 发布
阅读量215 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aiyubaobei/article/details/124053799
版权

在上一个博客中我们对string类进行了简单了解，我们知道了string类的一些常用的函数，这篇博客我们就来模拟实现一下string。

文章目录

string中的成员变量

class mystring
{
   private:
    	char* _str; // 用来存放字符串
    	size_t _size; // 字符串中的有效字符
    	size_t _capacity; // 字符串的容量
};

构造函数

默认构造函数

class mystring
{
    public:
    	void string(const char* str="")  // 给构造函数一个缺省值
            :_str(new char[1])
            ,_size(strlen(str))
            ,_capacity(_size)
         {
             assert(nullptr != str); // 不能给构造函数传空指针
             _str = new char[_capacity + 1]; // 因为一个字符串有一个隐藏的'\0'
             strcpy(_str, str);
         }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

拷贝构造

有时我们需要通过一个字符串对象来构造一个新的对象，而默认生成的拷贝构造只能实现浅拷贝，浅拷贝会导致我们在析构的时候出现问题，即对同一块内存重复释放，所以我们要自己实现拷贝构造。

class mystring
{
    public:
    	void string(const string& s) 
            :_size(s.size())
            ,_capacity(s.capacity())
         {
            _str = new char[strlen(s._str)]; // 重新申请一块空间
            strcpy(_str, s._str); // 将要拷贝的string类对象拷贝到新空间
         }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

通过一个字符串的子串来创建string对象的构造方法

class mystring
{
    public:
    	void string(const char* str, size_t n) 
            :_size(n)
            ,_capacity(_size)
         {
             _str = new char[_capacity + 1];
             int i = 0;
             while(i < n)
             {
                 _str[i] = str[i];
                 ++i;
             }
             _str[_size] = '\0'; // 需要加一个'\0'到数组中，才是完成的字符串
             
         }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

通过n个重复的字符来构造对象

class mystring
{
    public:
    	void string(size_t n, char c)
            :_size(n)
            ,_capacity(_size)
         {
            _str = new char[_capacity + 1];
            for(int i = 0; i < n; ++i)
            {
                _str[i] = c;
            }
            _str[_szie] = '\0';
         }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

析构函数

class mystring
{
    public:
    	~string()
        {
            delete[] _str; // 释放掉申请的空间
            _str = nullptr;
            _size = 0;
            _capacity = 0;
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

重写string的一些运算符

重写string的=符号

class mystring
{
    public:
    // 通过一个string对象赋值给一个string对象
    	string& operator=(const string& s) 
        {
            if(&s != this)
            {
                delete[] _str;  // 先释放原有的空间
                _str = new char[s.capacity];
                strcpy(_str, s._str);
                _capacity = s._capacity;
                _size = s._size;
            }
            return *this;
        }
    // 通过一个字符串给一个string对象赋值
    	string& operator=(const char* str)
        {
            delete[] _str;
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
            return *this;
        }
    
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

重写下标访问符 [ ]

class mystring
{
    public:
    	char& operator[](size_t index)
        {
            assert(index < _size);
            return _str[index];
        }
    // const对象访问的[]的下标访问符
    const char& operator[](size_t index) const
    {
        assert(index < _size);
        return _str[index];
    }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

重写==符号

class mystring
{
    public:
    	bool operator==(const string& s) const
        {
            if(_size != s._size)
            {
                return false;
            }
            size_t i = 0;
            while(i < _size)
            {
                if(_str[i] != s.str[i])
                {
                    return false;
                }
                else
                {
                    ++i;
                }
            }
            return true;
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

重写+=符号

class mystring
{
    public:
    	string& operator+=(const string& s)
		{
			int i = 0;
			size_t sz = s._size;
			while (i < sz)
			{
				if (_size == _capacity)
				{
					if (_capacity == 0)
					{
						_capacity = sz;
					}
					this->reserve(_capacity * 2);
				}
				_str[_size++] = s._str[i++];
			}
			_str[_size] = '\0';
			return *this;
		}

		string& operator+=(const char* s)
		{
			size_t sz = strlen(s);
			int i = 0;
			while (i < sz)
			{
				if (_size == _capacity)
				{
					if (_capacity == 0)
					{
						_capacity = sz;
					}
					this->reserve(_capacity * 2);
				}
				_str[_size++] = s[i++];
			}
			_str[_size] = '\0';
			return *this;

		}

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

重写>和<符号

class mystring
{
    public:
    	// 重写 <
		bool operator<(const string& s) const
		{
			int ret = strcmp(_str, s._str);
			if (ret < 0)
			{
				return true;
			}
			else {
				return false;
			}
		}

		// 重写 >
		bool operator>(const string& s)const
		{
			int ret = strcmp(_str, s._str);
			if (ret > 0)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

重写>>和<<

class mystring
{
    public:
		friend std::istream& operator>>(std::istream& out, tpm::string& str);
		friend std::ostream& operator<<(std::ostream& in, const tpm::string& str);
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};
std::istream& operator>>(std::istream& in, tpm::string& str)
{
		str.clear();
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = in.get();
		}
		return in;
}
std::ostream& operator<<(std::ostream& out, const tpm::string& str) 
{
	for (int i = 0; i < str._size; ++i)
	{
		out << str[i];
	}
		return out;
	}
}

迭代器

string的迭代器很简单，就是在string中定义一个内置类型

class mystring
{
    public:
    	typedef char* iterator; 
    	iterator begin()
        {
            return _str;
        }
    	
    	iterator end()
        {
            return _str+_size;
        }
    // 实现const迭代器
    	iterator begin() const
        {
            return _str;
        }
    
    	iterator end() const
        {
            return _str + _size;
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

改变string的大小

实现resize函数，它可以申请空间 ，并用n个字符进行初始化

class mystring
{
    public:
    	void resize(size_t n, char c)
        {
            if(n > _capacity)
            {
                char* tmp = new char[ n + 1 ];
                _capacity = n;
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
            }
            for(int i = _size; i < _capacity; ++i)
            {
                _str[i] = c;
            }
            _size = _capacity;
            _str[_size] = '\0';
        }
    // 申请空间但是不初始化
    	void resize(size_t n)
        {
            if(n < _size)
            {
                _szie = n;
            }
            if(n > _capacity)
            {
                char* tmp = new char[n+1];
                _capacity = n;
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
            }
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

reserve函数，它只改变string的大小，不对空间进行初始化

class mystring
{
    public:
    	void reserve(size_t n)
        {
            if(n > _capacity)
            {
                char* tmp = new char[n + 1];
                _capacity = n;
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
            }
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

实现字符串的字符尾插

class mystring
{
    public:
    	void push_back(char c)
        {
            if(_size == _capacity)
            {
                size_t sz = _capacity == 0?4:_capacity *2;
                char* tmp = new char[sz+1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = sz;
            }
            _str[_size] = c;
            ++_size;
            _str[_size] = '\0';
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

向一个字符串对象追加一个字符串

class mystring
{
    public:
    	string& append(const string& s)
        {
            int i = 0;
            size_t sz = s._size;
            while(i < sz)
            {
                if(_size == _capacity)
                {
                    if(_capacity == 0)
                    {
                        _capacity = sz;
                    }else
                    {
                         this->reserve(sz+1);
                    }
                }
                _str[_size++] = s._str[i++];
            }
            _str[_size] = '\0';
            return *this;
        }
    
    	string& append(const char* s)
        {
            size_t sz = strlen(s);
			int i = 0;
			while (i < sz)
			{
				if (_size == _capacity)
				{
					if (_capacity == 0)
					{
						_capacity = sz;
					}
					this->reserve(_capacity * 2);
				}
				_str[_size++] = s[i++];
			}
			_str[_size] = '\0';
			return *this;
        }
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
};

获取字符串属性的函数

class mystring
{
    public:
    	// 实现string类的c_str()函数
		const char* c_str() const
		{
			return _str;
		}

		// 实现string类的size()函数，获取string的有效字符个数
		size_t size() const
		{
			return _size;
		}

		// 实现string类的capacity()函数，返回容器大小
		size_t capacity() const
		{
			return _capacity;
		}

		// 实现string类的empty()函数
		bool empty() const
		{
			if (_size == 0)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
}

实现字符串的插入和删除

class mystring
{
    public:
		// 实现string类的insert函数
		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size >= _capacity)
			{
				if (_capacity == 0)
				{
					_capacity = 2;
				}
				this->reserve(_capacity * 2);
			}
			int i = _size;
			while (i >= (int)pos)
			{
				_str[i + 1] = _str[i];
				--i;
			}
			_str[pos] = c;
			_size += 1;
			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(str);
			assert(pos <= _size);
			size_t step = strlen(str);
			size_t sz = strlen(str) + _size;
			if (sz >= _capacity)
			{
				reserve(sz * 2);
			}
			int i = _size;
			while (i >= (int)pos)
			{
				_str[i + step] = _str[i];
				--i;
			}
			int p = pos;
			int j = 0;
			while (p < (int)pos + step)
			{
				_str[p++] = str[j++];
			}
			_size += step;
			_str[_size] = '\0';
			return *this;

		}
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
}

字符串的删除erase函数

class mystring
{
    public:
		// 实现string类的erase函数
		string& erase(size_t pos = 0, size_t len = npos)
		{
			assert(pos < _size);
			if (pos + len >= _size)//pos位置之后全为0
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}
    private:
    	char* _str;
    	size_t _size;
    	size_t _capacity;
}
_yiyi_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
模拟实现string类深浅拷贝
01-08
从构造，析构以及拷贝构造的方面理解string类的底层实现。 源代码获取： https://github.com/akh5/C-/blob/master/STL/Mystring.cpp string的底层通过字符指针char*通过构造函数申请对应大小的空间，并将指针指向其...
C++string类的实现
热门推荐
编程鸟
09-04 1万+
C++中提供了一种新的数据类型——字符串类型(string)。实际上string并不是C++的基本类型，它是在C++标准库中声明的一个字符串类，用这种数据类型可以定义对象，每一个字符串变量都是string类的一个对象。标准库类型string表示可变长的字符序列，使用string类型必须首先包含它的头文件。 作为标准库的一部分，string定义在命名空间std中。 【例】#include<str
string的模拟实现
qq_65285898的博客
12-11 702
STL首个类的模拟实现
string类的模拟实现
lang_965的博客
12-02 421
涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显示给出。，在释放时同一块空间被释放多次而引起程序崩溃。浅拷贝：编译器合成默认的拷贝构造，导致。
C++ string类的实现
FanJiangDaoHai的博客
03-10 2930
C++ string类实现，运算符重载，友元，动态扩容，构造函数，析构函数，iterator迭代器
简单实现string类
a2576014760的博客
04-26 1481
源码： #include<iostream> using namespace std; class String { private: char* _str;//指向字符串的指针 size_t size;//保存当前字符串长度 public: //构造函数 String(const char* str = "") { if (str == NULL) { _str = new char[1];//为了与delete[]配合使用 *_str = '\0';
模拟实现string，vector，list（双向链表）问题反思
最新发布
08-18
模拟实现string，vector，list（双向链表）问题反思
C++中string的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
c++string类的实现
11-23
1)代码注释很详细的，非常适合学习STL的 2）string类经常用到find find_first_of find_first_not_of find_last_of find_last_not_of substr replace等，以及联合使用来达到java中的split和trim 3) 有些函数返回的是MyString& 、Char& 等(引用)，MyString、Char 等（传值）这得看你返回的对象是函数的局部变量还是全局变量（或者类当前对象成员变量）；前者只能返回一个MyString、Char 等；后者强烈建议返回MyString& 、Char& 等(引用)；
模拟实现string超详解（C++）
m0_67430750的博客
04-23 427
简易版string模拟实现超详解
string的模拟实现(String)
库蒂尼奥的博客
11-15 324
string的兄弟String一、初始化与清理1.1构造函数1.2析构函数二、运算符重载2.1赋值运算符2.2其他运算符三、迭代器3.1 一、初始化与清理 1.1构造函数 1.2析构函数 二、运算符重载 2.1赋值运算符 2.2其他运算符 三、迭代器 3.1 ......
模拟实现string类
Mr.Li的博客
04-26 163
1. STL容器之string类 作为STL六大组件的容器，string是我们使用频率较高的一个容器，本文将从底层出发，了解string类的实现方式 2. 标准库中string类的常用接口 （1）默认成员函数 （2）容量 （3）迭代器 （4）增删查改 （5）字符串操作 具体的常用接口可以通过：www.cplusplus.com查看 3. 模拟实现string类 #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> #include
String类的实现
Nemo
05-21 289
C++中为我们提供了字符串类型（string），使得我们在处理字符串时非常方便。在此将实现我们常用的方法。 头文件： #pragma once #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <cstring> #include <assert.h> usi...
【C++】string类的模拟实现
qq_53893431的博客
07-04 266
经管跑路人的C++笔记
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您需要创建一个动态数组来存储字符串，同时实现一些方法来操作它。比如说，您可以创建一个构造函数来初始化字符串，实现一个拼接方法来将两个字符串合并，还可以实现一个查找方法来搜索字符串中的特定字符或子串。这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_yiyi_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值