【C++】string类模拟实现上篇(附完整源码）

于 2023-09-10 20:43:52 发布
阅读量925 收藏 18
点赞数 22
分类专栏： C++ STL标准模版库 文章标签： c++ 开发语言 c语言 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69423932/article/details/132773877
版权

目录

前言

在上一篇文章中，我们详细介绍了string类一些常用接口的使用，那这篇文章，我们将对string进行一个模拟实现，帮助大家理解的更加深刻。

1. string的基本结构

在上篇文章中我们了解：

string的底层其实就是一个支持动态增长的字符数组。那确定它的结构，接下来我们就开始模拟实现它。

首先新建一个头文件string.h，定义一个string类：

class string
{
    public :
    //成员函数
    private :
        char*  _str;
        size_t _size;
        size_t _capacity;
};

这里string类的三个成员变量，一个字符指针_str指向开辟的动态数组，_size标识有效数据个数，_capacity记录容量的大小（不包含’\0’）。

但是因为标准库里已经有string类，为了避免冲突，我们需要定义一个命名空间，把我们自己实现的string类放到自己的命名空间里面。

namespace w
{
    class string
{
    public :
    //成员函数
    private :
        char*  _str;
        size_t _size;
        size_t _capacity;

};
    
}

2. 构造函数、析构函数

2.1 构造函数的实现
2.1.1带参构造函数

首先我们来模拟实现一个带参构造函数：

我们知道标准库里string类的构造函数有很多，这里我们只模拟实现最常用的：
在这里插入图片描述

在之前的文章中我们提到尽量使用初始化列表进行初始化，我们可以这样写：
在这里插入图片描述
但是这里你会发现程序报错了，因为如果像上图一样初始化，首先涉及到权限放大的问题（之前文章有讲过）char* str被const修饰，不能被修改，但是赋给_str，_str是char* 类型的，可以修改。其次用常量字符串去初始化也不能被修改。

那怎么办呢？ 我们这里不直接传参而是开空间，用strcpy去进行拷贝：

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

顺便这里我们提供一个接口用来返回字符串：

 const char* c_str()
        {
            return _str;
        }

我们在创建一个test.cpp文件用来测试我们写的接口：
在这里插入图片描述

2.2析构函数

这里我们直接顺便给出析构函数：

~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }
2.3无参构造函数

我们有的时候还会遇到这样的场景：
在这里插入图片描述
所以这里需要我们去实现一个无参的构造函数。

假设这里的无参构造函数我们这样实现：
在这里插入图片描述

那这样真的可行吗？
如果这里_str传空指针那么在刚刚实现的c_str函数就会返回空程序，程序会崩溃。并且在标准库里的c_str接口即使传空也是会有返回值的。

那这里应该怎么办呢？ 我们可以这样写：

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

这里我们给_str开辟一个空间，然后给这块空间给上'\0'。这样就不会出现上面的问题了。

2.4无参和带参构造函数合并

我们之前讲过无参和带参的可以用全缺省。

我们来看几种写法：
在这里插入图片描述
能这样写吗？答案是肯定不能这样写类型就不匹配，一个是字符一个是字符串。
在这里插入图片描述
能这样写吗？ 答案是肯定不能。这样写strlen里的str就是空串了。

其实应该这样写：
在这里插入图片描述
这里我们直接给一个空串，常量字符串末尾是默认有"\0"的

3. string的遍历

3.1 operator[ ]

我们知道在标准库中可以通过下标去访问字符串中的某一个字符，下面我们来实现对[]的重载。

首先我们需要实现size()接口：
在这里插入图片描述

接下来我们来实现一下[]的重载：
在这里插入图片描述
在这里插入图片描述
这里我们实现了两个版本普通版本对应普通对象，const版本对应const对象，且这两个函数构成函数重载。

下面我们来验证一下：
在这里插入图片描述

3.2迭代器模拟实现 (简单实现）

除了[]可以遍历访问string对象，我们还可以用迭代器进行访问。

那迭代器我们说了大家可以理解成一个像指针一样的东西，但是不一定是指针。
我们最开始介绍了STL有好几个版本，不同的版本实现可能是不一样的。
那其实vs下string的迭代器呢就不是使用指针实现的，而G++下使用的SGI版本是指针实现的。
那这里我们模拟实现就使用指针来实现:
在这里插入图片描述

下面我们来验证一下：
在这里插入图片描述
在这里插入图片描述

同样的我们还可以使用范围for进行遍历：
在这里插入图片描述
范围for的底层就是用的迭代器。
大家可以理解成范围for的语法其实就跟我们之前学过的宏有点类似，它会被替换成迭代器，相当于把*it赋值给ch。范围for的底层就是无脑替换。

3.3 const迭代器模拟实现

这里我们再实现const版本给const对象使用：
在这里插入图片描述

4. 数据的增删查改

首先我们来实现一下push_back()和append().这两个都是插入数据，既然插入数据那我们就必须考虑扩容的问题。
在这里插入图片描述
那这里如果扩容的话，我们一次扩多少呢？
对于push_back来说一次扩二倍没问题，但是append一次扩二倍有可能是不行的。
为什么？
如果当前的容量是10，现在追加一个长度为25的字符串，扩容到原来的两倍才
20，也是不够用的。

那这里我们通过string的另一个接口reserve，它可以改变容量为我们指定的大小，帮助我们扩容。
下面我们就先来实现一下reserve。

4.1 reserve

我们先来看一下reserve怎么实现：
在这里插入图片描述
这里当参数n的值小于_capacity，如果不加这个if判断这里就会缩容。但是我们知道，库里的接口是不会缩容的。所以需要加上这个条件判断。

4.2 push_back和append

那接下来有了reserve我们继续来实现push_back和append。

在这里插入图片描述
push_back这里我们直接选择两倍扩。

在这里插入图片描述
这里append最少扩容到_size + len.

下面我们来实现一下：
在这里插入图片描述

4.3 +=

我们虽然有push_back和append但是我们更喜欢用重载的+=。当然+=的底层也是可以用push_back和append实现的。
在这里插入图片描述

下面我们来实现一下：
在这里插入图片描述

4.4 insert

对于insert我们主要实现库里的这两个版本：
在这里插入图片描述
在这里插入图片描述

首先我们来实现一下在pos位置插入n个字符：
逻辑其实是比较简单的。首先判断一下，是否需要扩容，然后就插入数据，如果往中间插就需要挪动数据。
在这里插入图片描述

这样写有没有问题呢？ 我们来测试一下：
在这里插入图片描述
好像没什么问题啊。真的没问题吗？

我们来看一种特殊情况：当pos = 0 时插入数据：
在这里插入图片描述

程序这里挂了。那为什么呢？
这里当pos = 0时，end等于0时还会进入循环,end再- -会变成多少？ 是-1吗？
在这里插入图片描述
这里end的类型是szie_t，无符号整型，所以end为0后再- -并不是-1，而是整型最大值，发生越界，循环也没正常结束，所以程序崩了。

那怎么解决呢？把end改成int可行吗？

这里也是不可行的。end和pos比较，end变成int，但是pos是size_t类型，这里是会发生整型提升(C语言知识）。那我们应该如何解决呢？

这里解决方法有很多，我们采用其中一种利用我们之前文章中提到的npos解决：
在这里插入图片描述

在这里插入图片描述

我们再来测试一下：
在这里插入图片描述

刚才是插入一个字符，现在我们再来实现插入字符串的。那么逻辑和上面其实是一样的。只不过上面我们只需要挪出n个空间就可以了，那这里我们需要挪动数据腾出strlen(str)个空间。
在这里插入图片描述

下面我们来测试一下：
在这里插入图片描述

4.5 erase

那么接下来我们来实现一下erase，从pos位置删除len个字符：
在这里插入图片描述

对于erase首先第一种情况就是pos+len小于字符串的长度，那我们需要把pos位置开始的后len个字符删掉，但是仍然保留后续字符。那这里就是挪动后面的数据，把需要删除的覆盖掉就行。
那其它情况就是len比较大，pos+len直接大于等于字符串的长度，那就把pos后面的全部删掉。或者没有传pos这个参数，缺省值npos，那也要把后面的全删，所以这两种情况可以统一处理。这里只需要把pos位置给成“\0”就行了。
在这里插入图片描述

我们来测试一下：
在这里插入图片描述

当然为了和标准库里的一致我们这里也使用引用返回：
在这里插入图片描述

4.6 find

下面我们来实现一下find。find的实现其实很简单，遍历去找，找到了就返回下标，找不到就返回npos。
在这里插入图片描述

当然find还支持从pos位置开始查找一个字符串：在这里我们复用C语言中的strstr去查找。在这里插入图片描述

下面我们来测试一下：
在这里插入图片描述

4.7 substr

下面我们再来实现一下substr。它的逻辑也是很简单的。

这里稍微需要注意的是我们需要条件判断当截取的字串足够长，我们截取的长度就是pos位置一直到字符串的末尾。
在这里插入图片描述

5. 拷贝构造

我们现在先来写一段这样的代码：
在这里插入图片描述
这里有一个拷贝构造，s2是s1拷贝构造而来的。

5.1 浅拷贝默认拷贝构造

在之前类和对象的文章中，我们知道，拷贝构造函数我们自己不写编译器是会默认生成的，这里我们直接运行上面的代码：
在这里插入图片描述

这里程序出错发生了一个经典的浅拷贝的问题。在之前的文章中我们也有讲过若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数拷贝对象 按内存存储字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝，就会出现问题。

5.2 深拷贝拷贝构造函数

这里就需要我们自己去实现拷贝构造函数，完成深拷贝：
在这里插入图片描述
在这里插入图片描述
下面我们来测试一下：
在这里插入图片描述

6. 源码(上部分)

6.1 string.h
#include <iostream>
using namespace std;
namespace w
{
    class string
{
    public :
        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;
		}

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

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


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

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

        size_t size() const
        {
            return _size;
        }

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

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

          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)
			{
				// 2倍扩容
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;

			++_size;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				// 至少扩容到_size + len
				reserve(_size+len);
			}

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

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

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

        	void insert(size_t pos, size_t n, char ch)
		{
			assert(pos <= _size);

			if (_size +n > _capacity)
			{
				// 至少扩容到_size + len
				reserve(_size + n);
			}

			// 添加注释最好
			size_t end = _size;
			while (end >= pos && end != npos)
			{
				_str[end + n] = _str[end];
				--end;
			}

			for (size_t i = 0; i < n; i++)
			{
				_str[pos + i] = ch;
			}

			_size += n;
		}

        	void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);

			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				// 至少扩容到_size + len
				reserve(_size + len);
			}

			// 添加注释最好
			size_t end = _size;
			while (end >= pos && end != npos)
			{
				_str[end + len] = _str[end];
				--end;
			}

			for (size_t i = 0; i < len; i++)
			{
				_str[pos + i] = str[i];
			}

			_size += len;
		}

        string& erase(size_t pos, size_t len = npos)
		{
			assert(pos <= _size);

			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;

				_str[_size] = '\0';
			}
			else
			{
				size_t end = pos + len;
				while (end <= _size)
				{
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}

            return *this;
		}

        size_t find(char ch, size_t pos = 0)
		{
			assert(pos < _size);

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

			return npos;
		}

		size_t find(const char* str , size_t pos = 0)
		{
			assert(pos < _size);

			const char* ptr = strstr(_str + pos, str);
			if (ptr)
			{
				return ptr - _str;
			}
			else
			{
				return npos;
			}
		}

        string substr(size_t pos = 0, size_t len = npos)
		{
			assert(pos < _size);

			size_t n = len;
			if (len == npos || pos + len > _size)
			{
				n = _size - pos;
			}

			string tmp;
			tmp.reserve(n);
			for (size_t i = pos; i < pos + n; i++)
			{
				tmp += _str[i];
			}

			return tmp;
		}

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

    public:
		const static size_t npos;

};
    
	const size_t string::npos = -1;
}
6.2 test.cpp
#include "Mystring.h"

void test_string1()
{
    w ::string s1("hello world");
    cout << s1.c_str() << endl;

    for (size_t i = 0; i < s1.size(); i++)
    {
        cout << s1[i] << " ";
    }
    cout << endl;

    w ::string::iterator it = s1.begin();
    while (it != s1.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout <<endl;
    
    for (auto ch : s1)
    {
        cout << ch <<" ";
    }
    cout <<endl;
}

void test_string2()
{

	w::string s1("hello world");
	cout << s1.c_str() << endl;

	s1.push_back(' ');
	s1.push_back('#');
	s1.append("hello");
	cout << s1.c_str() << endl;

    w::string s2("hello world");
	cout << s2.c_str() << endl;

	s2 += ' ';
	s2 += '#';
	s2 += "hello code";
	cout << s2.c_str() << endl;

}

void test_string3()
{
	w::string s1("helloworld");
	cout << s1.c_str() << endl;

	s1.insert(5, 3, '#');
	cout << s1.c_str() << endl;

	s1.insert(0, 3, '#');
	cout << s1.c_str() << endl;

    w::string s2("helloworld");
	s2.insert(5, "%%%%%");
	cout << s2.c_str() << endl;
	
}

void test_string4()
{
	w::string s1("helloworld");
	cout << s1.c_str() << endl;

	s1.erase(5, 3);
	cout << s1.c_str() << endl;

	s1.erase(5, 30);
	cout << s1.c_str() << endl;

	s1.erase(2);
	cout << s1.c_str() << endl;
}

void test_string5()
{
	w::string s1("helloworld");
	cout << s1.find('w',2) << endl;

	
}

void test_string6()
{
	w::string s1("hello world");
	w::string s2(s1);

	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;

}




int main()
{
    test_string6();
    return 0;
}

7. 总结

文章篇幅有限，剩余内容将在下篇进行讲解。

一个努力学习编程的人
关注
  • 22
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 31
    评论
专栏目录
c++string函数源码
07-20
c++string函数源码 无修改
【C++】STL之string类源码剖析
phoenixFlyzzz的博客
04-21 2226
string类的模拟实现，功能有字符串元素的随机访问、迭代器遍历、字符串追加/删减/查找、字符串随机插入、字符串扩容与修改长度、重载输入/输出运算符
Cpp学习——string模拟实现
qq_41934502的博客
08-15 231
string类重要函数模拟实现
C++入门篇之string类的底层原理和模拟实现
最新发布
满天的博客
08-30 817
string类的模拟实现和string的底层原理
C++String 类完整源代码
07-08 2616
MyString 类完整源代码   MyString.h文件 /*********************************************************** //Copyright (c) 2013 道合|SameIdeal.com  All rights reserved. ***********************************************
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
易语言内存模拟C++数据结构-易语言
06-11
上，虽然一路顺风，但是感觉有点乱，比如数据结构之类的，有些的结构复杂，要自己计算偏移量 于是，灵感来了，把C++的结构代码复制到易语言里，然后解析一下，如果调用C++返回的是数据 结构的话，把指针取出来，然后...
JAVA上百实例源码以及开源项目源代码
09-17
Applet钢琴模拟程序java源码 2个目标文件，提供基本的音乐编辑功能。编辑音乐软件的朋友，这款实例会对你有所帮助。 Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件，EJB来模拟银行ATM...
JAVA上百实例源码以及开源项目
01-03
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4648
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
功能强大的String类源码(C++)
06-09
用C++语言实现的一个功能强大的String类，该类包含对字符串的各种灵活操作，40多个强大的API(CharAt,Length,IndexOf,Replace,Add,Insert,Remove.....), 为学习数据结构的朋友提供了很好的帮助。
c++string类源码
04-01
c++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& 等(引用)；
c++中string类的源代码
12-27
关于string类的自定义，如果你对string不了解，可帮助你理解其功能有助于c++的学习
string源代码.pdf
10-08
string源代码.pdf
C++中string类的实现
m0_65014490的博客
07-22 1242
在c++的标准库中我们处理字符串的时候需要使用string类，库中的使用接口都非常方便。为了让我们更加了解有关库中的相关函数，我们需要自己来实现一遍。
C++之string源代码详解
m0_57330725的博客
03-19 3570
stiring 相比于c的char 要方便多了，string里有很多的库函数，现在我们来把库函数的实现讲解下 #include<iostream> #include<string.h> #include<assert.h> using namespace std; namespace WGX//建一个空间域 { class string { public: typedef char* iterator;//迭代器 typedef const cha
C++源码剖析——string和string_view
梦的灰色边沿...
03-21 833
之前看过侯老师的《STL源码剖析》但是那已经是多年以前的，现在工作中有时候查问题和崩溃都需要了解实际工作中使用到的STL的实现。因此计划把STL的源码再过一遍。
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一个努力学习编程的人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值