C++ STL --＞模拟实现string

最新推荐文章于 2024-06-04 05:41:15 发布
最新推荐文章于 2024-06-04 05:41:15 发布
阅读量274 收藏 6
点赞数 5
分类专栏： C++ 文章标签： c++ stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FBI_BAIGOU/article/details/136385943
版权

文章目录


在之前的文章中 C++ STL–>String类详解，介绍了一下STL中string类的基本使用 这篇文章将模拟实现string类的常用函数

string模拟实现

模拟实现的目的就是为了更好的使用STL

模拟实现string类函数接口

namespace ding
{
   class string
   {
   public:
        string(const char* str = "");
        string(const string& s);
        string& operator=(const string& s);
        ~string();
        //=======================================================
        // iterator
        typedef char* iterator;
        iterator begin();
        iterator end();
        //=======================================================
        // modify
        void push_back(char c);
        void append(const char* str);
        string& operator+=(char c);
        string& operator+=(const char* str);
        void clear();
        void swap(string& s);
        const char* c_str()const;
        //=======================================================
        // capacity
        size_t size()const;
        size_t capacity()const;
        bool empty()const;
        void resize(size_t n, char c = '\0');
        void reserve(size_t n);
        //=======================================================
        // access
        char& operator[](size_t index);
        const char& operator[](size_t index)const;
        //=======================================================
        //relational operators
        bool operator<(const string& s);
        bool operator<=(const string& s);
        bool operator>(const string& s);
        bool operator>=(const string& s);
        bool operator==(const string& s);
        bool operator!=(const string& s);
        // 返回c在string中第一次出现的位置
        size_t find(char c, size_t pos = 0) const;
        // 返回子串s在string中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const;
        // 在pos位置上插入字符c/字符串str，并返回该字符的位置
        string& insert(size_t pos, char c);
        string& insert(size_t pos, const char* str);
        // 删除pos位置上的元素，并返回该元素的下一个位置
        string& erase(size_t pos, size_t len);
    private:
        char* _str;       //存储字符串
        size_t _capacity; //记录字符串当前的容量
        size_t _size;     //记录字符串当前的有效长度
   };
   ostream& operator<<(ostream& _cout, const ding::string& s);
   stream& operator>>(istream& _cin, ding::string& s);
};

为了解决和标准库中string命名发生冲突，这里使用自己的命名空间解决

默认成员函数

构造函数

无参构造函数：构造空字符串 空字符串里面是有一个\0的 并不是什么都没有

string::string()
	:_str(new char [1])
	,_capacity(0)
	,_size(0)
{
	_str[0] = '\0';
}

带参构造函数

string::string(const char* str)
	:_size(strlen(str))
{
	_capacity = _size;
	_str = new char[_capacity + 1];//多开辟一块空间存放\0
	strcpy(_str, str);
}

省值可以将无参的和带参的构造函数写成一个函数

函数声明:string(const char* str = "");

注意 这里缺省值只能给函数声明，定义的时候不能再使用缺省值

实现：

string::string(const char* str )
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

析构函数

这里的构造函数用new从堆区申请空间，所以析构函数需要自己实现去主动释放资源，编译器默认生成的无法满足需求

string::~string()
{
	delete[] _str;
	_str = nullptr;
	_size = _capacity = 0;
}

拷贝构造函数

这里如果使用编译器默认生成的拷贝构造函数去初始化对象 在对象生命周期结束时 c++编译器自动调用析构函数会出错 如下图

image.png
原因：这里是浅拷贝 s1和s2共用同一块地址空间，在对象s1,s2生命周期结束时，调用析构函数。对s1进行析构时，已经将资源释放掉了，而s2还不知道资源已经被释放，再次对其资源进行释放时，就会出现访问违规。
image.png
关于深浅拷贝

浅拷贝：编译器只会将对象中的值拷贝过来。拷贝的对象和源对象共用同一块地址空间，对其中一个对象的修改会影响到另一个对象
深拷贝：拷贝的对象与源对象使用不同的地址空间，二者互不干扰。

image.png

image.png
在这里，我们应该实现的是深拷贝，编译器默认生成的不能完成。需要自己实现一个拷贝构造函数
代码实现：

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

赋值运算符重载函数

赋值时，同样应该采用深拷贝的方式进行赋值
首先将原来的空间释放掉，然后申请新空间进行拷贝
注意：如果自己给自己赋值，应该进行判断。否则将自己释放后，在进行赋值，会出错

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

这里申请临时对象是为了防止申请空间失败，对原来的数据造成破坏

迭代器相关函数(iterator)

迭代器在string类中的实现很简单 就是给字符指针取了个高大上的名字
typedef char* iterator;
typedef const char* const_iterator;

begin()

返回字符串的起始位置的地址

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

end()

返回字符串结束位置的地址 即\0位置的地址

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

利用迭代器遍历字符串：
在底层 用迭代器遍历字符串，实际上就是用指针的方式去遍历

string s1("Hello world");
auto it = s1.begin();
while (it != s1.end())
{
        cout << *it << endl;
        it++;
}

capacity(容量和大小函数)

size函数

返回字符串的元素个数不包含\0;

size_t string::size()const
{
        return _size;
}

capacity函数

返回字符串的有效空间大小

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

reserve函数

扩容
reserve函数规则：

  • 大于当前对象的capacity时，将capacity扩大到n或者大于n
  • 当n小于当前对象的capacity时，什么也不做。(不会缩容)
void string::reserve(size_t n)
{
        _capacity = n + _capacity;
        char* tmp = new char[_capacity];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        //_size 不用处理
        //_size = strlen(_str);
}

resize函数

扩容+初始化
resize函数的规则:

  • 当n大于当前对象的size时 将size扩大到n 若未指定字符 默认为’\0’
  • 当n小于当前对象的size时 将size缩小到n
void string::resize(size_t n, char c = '\0')
	{
		if (n <= _size)
		{
			_size = n;
			_str[_size] = '\0';
		}
		else
		{
			if (n > _capacity)
			{
				reserve(n);
			}
			//加数据
			size_t i = _size;
			while (i < n)
			{
				_str[_size] = c;
				i++;
			}
			_size = n;
			_str[_size] = '\0';
		}
	}

modfiy(修改字符串函数)

push_back(尾插)

在字符串结尾插入一个字符
插入之前首先要考虑一下容量是否足够 不够需要扩容

void string::push_back(char c)
{
        //扩容
        if (_size >= _capacity)
        {
                _capacity = _capacity == 0 ? 2 : _capacity;//处理空串
                reserve(_capacity * 2);
        }
        //push_back
        _str[_size] = c;
        ++_size;
        //处理\0
        _str[_size] = '\0';
}

注意：插入一个字符后需要自己处理一下字符串结束标志\0

append(尾插一个字符串)

在字符串尾部插入一个字符串
在插入之前还是首先要检查一下容量是否足够

void string::append(const char* str)
{
    //扩容
    size_t len = strlen(str);
    if (_size + len >= _capacity)
    {
        _capacity = _capacity == 0 ? len : _capacity;//处理空串
        reserve(_capacity + len);
    }

    strcpy(_str+_size, str);
    _size += len;
}

注意:这里使用strcat也可以完成。但是strcat需要遍历找尾，效率太低，使用strcpy即可。strcpy会处理字符串结束标志\0，不用自己手动处理

+=赋值运算符重载

+=运算符重载实现很简单了 直接函数复用即可

string& string::operator+=(char c)
{
    push_back(c);
    return *this;
}
string& string::operator+=(const char* str)
{
    append(str);
    return *this;
}
string& string::operator+= (const string& str)
{
    append(str.c_str());
    return *this;
}

这里的c_str()函数就体现出价值了。append函数的形参是const char* 类型 而str是string类型 直接传参会导致参数类型不匹配错误。使用c_str转换一下类型即可

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

注意：这里的c_str()实现一个const成员函数即可，cosnt和非const对象都可以调用。如果只实现非cosnt版本的话，const对象去调用c_str函数则会出错。

clear

清空字符串中的有效字符，不会改变底层空间的大小(不会影响容量的大小)

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

find

默认从0(下标)位置开始查找，返回第一个匹配项的下标位置,找不到返回npos
npos：static const size_t npos = -1;

size_t string::find(char c, size_t pos) const
{
    for (size_t i = 0; i < _size; i++)
    {
        if (_str[i] == c)
        {
            return i;
        }
    }
    //没找到
    return npos;
}

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

}

insert

在指定位置插入n个字符

string& string::insert(size_t pos, size_t n,char c)
{
        //扩容
        if (_size + n >= _capacity)
        {
                reserve(_capacity+n);
        }
        //挪动数据
        int end = _size;//会把\0挪动
        while (end >= (int)pos)
        {
                _str[end + n ] = _str[end];
                --end;
        }
        while (n--)
        {
                _str[pos] = c;
                pos++;
        }
        _size += n;
        return *this;
}

在指定位置插入字符串

string& string::insert(size_t pos, const char* str)
{
        assert(pos <= _size);
        size_t len = strlen(str);
        //扩容
        if (_size + len >= _capacity)
        {
                reserve(_capacity + len);
        }
        //挪动数据
        int end = _size;
        while (end >= (int)pos)
        {
                _str[end + len] = _str[end];
                --end;
        }
        strncpy(_str + pos, str, len);//不会处理\0
        return *this;
}

pos可以通过find函数查找指定
比如

string s2("Hello");
size_t pos2 = s2.find('e');
s2.insert(pos2, 5, 'x');//在e的前面插入5个x
cout << s2.c_str() << endl;

erase

删除指定位置指定长度的字符(不指定长度全部删除)

  • 当长度大于字符串长度时，直接在pos位置赋值\0 即可
    PixPin_2023-12-04_21-21-09.gif
  • 其他情况挪动数据删除即可。

PixPin_2023-12-04_21-25-01.gif

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

访问字符串相关函数(access)

[]运算符重载

[]运算符重载函数目的是为了能让string对象像字符数组一样，使用[]+下标的方式进行访问
通过[]+下标，可以访问对应下标位置的元素。模拟实现时把对应位置的引用返回即可 这样可读可写

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

front && back函数

获取字符串有效元素第一个元素和最后一个元素(\0之前的)

image.png

char& string::front()
{
        return _str[0];
}
const char& string::front() const
{
        return _str[0];
}
char& string::back()
{
        return _str[_size - 1];
}
const char& string::back() const
{
        return _str[_size - 1];
}

关系运算符重载函数(relational operators)

关系运算符有 == 、!=、 <、 <=、 >、 >= 六个
实现其中一个==和> 或者< 函数复用一下，其他的就全部能实现了

bool string::operator<(const string& s)
{
        return strcmp(_str, s.c_str()) < 0;
}
bool string::operator==(const string& s)
{
        return strcmp(_str, s.c_str()) == 0;
}
bool string::operator<=(const string& s)
{
        return *this < s || *this == s;
}
bool string::operator>(const string& s)
{
        return !(*this <= s);
}
bool string::operator>=(const string& s)
{
        return  *this > s || *this == s;
}
bool string::operator!=(const string& s)
{
        return !(*this == s);
}

>>和<<的重载

<<重载

<< 的重载是为了让string对象 像内置类型一样，直接使用<<进行输出
重载时就是遍历一遍string对象，string对象存的是char类型，在使用<<输出即可

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

注意: cout的类型是ostream类类型;返回ostream的引用是为了连续输出

>>重载

<<的重载是为了让string对象可以像内置类型一样，直接使用cin进行输入。
输入时应该注意，先清空对象中的数据在进行输入。

//>>运算符的重载
istream& operator>>(istream& in, string& s)
{
    s.clear(); 
    char ch = in.get(); 
    while (ch != ' '&&ch != '\n') 
    {
            s += ch; 
            ch = in.get(); 
    }
    return in; 
}

注意这里不能使用>>直接输入char类型 要用cin对象的成员函数get()
因为>> 会将空格或者\n当成默认的分隔符 ，ch不会向缓冲区中拿空格或者\n。
导致循环一直无法终止，显然不符合要求。C++ cin对象有一个成员函数get(),会忽略空格和\n。都会从缓冲区中读取。

参考源码

C++下等马
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ STL - string 成员函数 + 模拟实现
TPON的博客
08-20 1135
STL - string成员函数 + 模拟实现
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
C++的STL---＞string类
qq_56628506的博客
07-19 342
string类的学习
C++STL---模拟实现string
weixin_73919606的博客
05-29 870
我们这篇文章进行string的模拟实现。
C++ STL --- string类模拟实现
weixin_57761086的博客
08-27 644
模拟实现C++string对象，前要讲解C语言中的strlen、strcpy、strncpy、strcat、memset、memcpy函数来铺垫。模拟实现了构造函数，拷贝构造函数，析构函数，赋值运算重载函数，+=重载，扩容函数，迭代器，查找函数，赋值函数。[]的重载。正反向的首尾迭代器。............
C++ STL-＞list模拟实现
FBI_BAIGOU的博客
02-16 1229
list。
C++ STL ---- string
EQUINOX1的博客
05-19 232
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++的STL----＞list
qq_56628506的博客
07-22 512
STL--->list
【C++】STL-string模拟实现
chuxinchangcun的博客
12-22 6043
public:string是一个管理字符数组的类,要求这个字符数组结尾用\0标识1.拷贝构造和赋值重载实现深拷贝2.增删查找的相关接口(跟顺序表类似)3.重载了一些常见的运算符 如: > < >> 加const2.只写接口函数 ->不加const3.可读可写接口函数 ->分为加const版本和不加const版本。
C++STL---string知识汇总
weixin_73919606的博客
05-26 776
我们现在开始C++STL的学习，从这时开始我们就要锻炼自己查看英文文档的能力，每种数据结构都有上百个接口函数，我们把他们全部记下来是不可能的，所以我们只记最常见的20几个接口，其他的大概熟悉有什么功能，用的时候去查看文档。
[ C++ ] STL---string类的模拟实现
m0_58963318的博客
03-17 958
string类的模拟实现
stl-thumb:STL文件的缩略图生成器
05-13
Stl-thumb是用于STL文件的快速轻量级缩略图生成器。 它可以在Linux和Windows的文件管理器中显示STL文件的预览。 它是用Rust编写的，并使用OpenGL。 安装 视窗 Stl-thumb需要64位Windows 7或更高版本。 最新版本并...
C++ stl-list.h(SGI)
10-12
有关list的源代码文件（SGI版本）
C++ - SGI 版本 STL源码
10-25
C++ SGI版本的STL(标准模板库) 源码 在网上找了很久没有找到直接打包的STL源码, 就打包了一下发出来了 SGI版本的，比较容易阅读 可读性还可以有需要的可以拿走
STL库string类的模拟实现
02-28
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。 5. 注意，这个类独立于所...
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
最新发布
Ddddddd_158的博客
06-04 311
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
CrossOver支持M4新品吗？苹果M4芯片对游戏支持的怎么样？
软妹子的博客
06-01 1127
CrossOver是一款可以在不同平台之间无缝切换的软件，它可以让你在MacOS或者Linux操作系统上运行Windows应用程序，无需安装双系统或虚拟机。CrossOver是基于Wine项目开发的，Wine是一个可以在非Windows平台上运行Windows应用程序的兼容层。那么，CrossOver是否支持M4新品呢？M4芯片又对游戏支持的怎么样呢？本文将从以下几个方面来探讨这个问题。M4芯片正式亮相，首发产品是2024款的iPadPro。
C++候捷stl-视频笔记2
Mhypnos的博客
05-31 810
候捷stl标准库学习笔记
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 448
数学 构造
c++ 面向对象 _ stl 的应用还原键盘输入
11-14
该方法可以利用输入流来读取键盘输入，并使用STL中的string类来保存输入的内容。 另外，我们可以使用STL中的容器来存储键盘输入的多个字符。例如，使用vector类来存储按键的顺序，每当用户按下一个键，就将其添加到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

C++下等马

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

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

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

打赏作者

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

抵扣说明：

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

余额充值