string模拟

已于 2024-08-18 18:52:17 修改
阅读量856 收藏 80
点赞数 87
分类专栏： c++学习 文章标签： AIGC 大模型 c++ python java stl 青少年编程
于 2024-08-17 12:01:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80105876/article/details/141223290
版权

本章准备对string模拟进行讲解，以下是string的学习网址：

string - C++ Reference (cplusplus.com)

        string本质可以理解为储存char类型的顺序表，其中string的迭代器用一个char*就可以解决。所以string类成员变量如下：

这里用了一个命名空间是为了区分库里面的string。接下来就对需要实现的函数一一讲解。

目录

一、构造函数

二、迭代器

三、运算符重载

1.关系运算符重载

2.<<和>>的重载

四、Capacity

1.resize接口：

2.reserve接口：

五、增删查

六、源码

一、构造函数

        涉及到动态内存申请的类是不能直接用编译器提供的默认构造函数，因为它无法完成深拷贝等等问题，所以需要我们自己来完成这一部分。

1.默认构造

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

        在写这个函数时需要注意，不能用sizeof来计算st的所占字节空间，这里sizeof只能计算到st这个变量所储存的内容占用的字节空间，而st所储存的是字符串的地址，所以占用的空间为4/8字节。 

        这里还要注意一个点strlen做计算时并没有算入'\0'，所以在申请内存时需要加上1。

2.拷贝构造

string拷贝构造函数的最本质还是用了字符串拷贝函数strcpy，如下：

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

        当然还有更方便的写法，我们可以借助已写好的默认构造函数去构造一个对象然后与需要拷贝的对象交换，那么我们就得先写swap函数，而不能用库里面的swap，该方法称为现代写法，在效率上并没有提升只是相当于让编译器去帮我们写，如下：

void swap(string& str)
{
	std::swap(_str, str._str);
	std::swap(_capacity, str._capacity);
	std::swap(_size, str._size);
}
string(const string& st)
{
	string sv(st._str);
	swap(sv);
}

3.赋值运算重载

该函数也一样可以用现代写法，如下：

string operator=(string st)
{
	swap(st);
	return *this;
}

        这里需要注意，因为这里用到swap直接对形参进行改变，所以这个不能加const和不能用引用传参。

4.析构函数

只要涉及到动态内存申请一定要自己写析构函数，默认生成的析构函数释放不了内存。如下：

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

        注意：对于一次性申请多个元素的内存空间要用delete[ ]去释放，用delete释放内存则会出现内存泄漏，或者不确定的问题。

二、迭代器

        每个容器都有迭代器，平时写代码我们并不用关心它们内部怎么实现，只要需要知道它的用法和功能，而且会用一个容器的迭代器就会用其他所有容器的迭代器，这就是封装的好处，而对于string的迭代器是相对比较简单的，因为string本质就是一个顺序表可以对数据随机访问。

如下：

三、运算符重载

运算符重载方面我们依次来设计以下函数：

char 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);
bool operator!=(const string& s);
ostream& operator<<(ostream& out, string& s);
istream& operator>>(istream& put, string& s);

对于[ ]的重载我们直接返回一个_str[index]就可以解决

        char operator[](size_t index)
        {
                return _str[index];
        }

1.关系运算符重载

<符号重载的实现底层还是调用了strcmp函数，如下：
        bool operator<(const string& s)
        {
                return strcmp(_str, s._str) < 0;
        }
        bool operator==(const string& s)
        {
                return strcmp(_str, s._str) == 0;
        }

        对于剩下的关系运算符只需复用<和==运算符即可，具体实现在最后源码给出。对于+和+=重载会在下面增删查部分进行讲解。

2.<<和>>的重载

        需要注意因为每个类的成员函数的参数都隐藏着一个this指针，而且this指针处于第一个参数位置，对于<<和>>运算符都是双目运算符（即只能有两个操作数）所以重载的函数只能有两个参数，而如果把<<，>>重载成类的成员函数的话，this指针已经占用了第一个参数位置，最后在使用的时候只能这样：操作对象<<cout 或 操作对象>>cin，这样用上去是十分别扭的而且很容易出错，所以这两个重载函数就不能作为类成员，需要在类外声明或实现。

        对于<<，>>重载函数是避免不了访问类成员变量的，而类成员变量我们已经把它设置为私有，在类外是无法访问的，所以这里把这两个重载函数设为类的友元函数就可以很好的解决。

对于<<（即输出）重载比较简单，就不过多讲解，如下：

接下来是>>

        这里有一个细节，在给一个对象输入数据之前，是先要把原数据清空的，所以需要用一个clear函数，在等会我们会实现，这里先使用。

        为了处理频繁扩容可以会消耗效率的问题，我们可以先用一个数组储存用户输入的内容，然后最后一次性储入对象中，字符读取终止的条件我们可以用空格或换行，但是由于cin会自动忽略空格字符和换行符，所以可以用cin.get()读取，然后再用while循环做判断。

        注意：在把所有读取到的数据储入对象后还需要手动添加'\0'

 这里的+=重载同样我们在后面再来实现。

四、Capacity

该部分我们主要实现库函数接口的以下红圈部分。

        对于size和capacity接口的实现比较简单直接返回相应的成员函数即可，empty的话返回_size==0即可，现在重点来看一看其它接口。 

1.resize接口：

        它的功能是改变string对象中的元素个数。如str.resize(n，m)表示把str字符串的元素改为n个，如n大于str的size那么多余部分用m字符填充。

void resize(size_t n,char m='?')
{
	while (_size < n)
	{
		_str[_size++] = m;
	}
    _size = n;
}

2.reserve接口：

        它的功能是预开空间，如str.reserve(n)表示把str的空间改为n个元素的空间大小，但它分有以下情况：

  • n > str._capacity，进行扩容。
  • str. _size < n < str._capacity，进行缩容。
  • n==str. _capacity，不做任何处理
  • n<str. _size，行为未定义（即没有明确的标准，具体取决于编译器，可能会把原数据缩小到n，也可能不做任何更改）

        那么这里为了方便当n<str. _size时我们就不做任何更改，注意这里_capacity的实现跟库里面保持一致并不用把'\0'占的空间算入。如下：

void reserve(size_t n)
{
	if (n < _size)
		return;
	char* st = new cha[n + 1];
	strcpy(st, _str);
	delete[] _str;
	_str = nullptr;
	_size = n;
	_capacity = n;
}

clear接口的话直接把_size置为0即可，不必要对其他数据进行改动数据。

五、增删查

该部分我们主要实现库函数接口的以下红圈部分。

        其中前三个接口核心在于push_back，可以先完成第三个接口，剩下两个接口对push_back复用即可。首先需要判断是否需要扩容，如果需要就进行扩容然后存放数据，不要忘记存放完数据后需要存入'\0'。如果函数是在类外实现的所以需要添加string::来指明类域。如下：

        swap函数在拷贝构造部分已经实现，pop_back函数的话直接把_size减减即可，现在重点来分析一下insert和erase。

        insert函数功能是在指定位置之前插入数据，erase的作用是删除指定位置的数据。string类本质是顺序表那么在做这个操作时就需要挪动数据。比如在pos位置之前插入数据那么就需要把pos位置及以后的所有数据都往后移动一位，从而把pos位置空出来填入新的位置。删除pos位置的数据就是要把pos以后的所有数据整体往前挪动一位，把pos位置覆盖。

        需要注意的是这里会引发一个迭代器失效的问题，如果insert发生扩容那么原空间就被弃用（内存释放），如果还使用该对象的迭代器就会导致程序崩溃。

        erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理
论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs开发环境也把该位置的迭代器视为失效。

        为考虑迭代器失效的问题库里面的规定是insert函数最后需要返回原pos指向的迭代器。esare函数最后要返回被删除数据的下一位数据的迭代器，这样就可以方便对原迭代器更新。

实现如下：

string::iterator string::insert(size_t pos,char c)
{
	if (_size == _capacity)
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	int end = _size;
	while (end != pos - 1)
	{
		_str[end + 1] = _str[end];
		end--;
	}
	_str[pos] = c;
	_size++;
	return begin() + pos + 1;
}
string::iterator string::erase(size_t pos)
{
	int bin = pos;
	while (bin != _size)
	{
		_str[bin] = _str[bin + 1];
		bin++;
	}
	_size--;
	return begin() + pos;
}

六、源码

​
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
namespace byte
{
	class string
	{
	public:
		typedef char* iterator;
		friend ostream& operator<<(ostream& out, string& s);
		friend istream& operator>>(istream& put, string& s);
	public:
		string(const char* st = "")
		{
			size_t sz = strlen(st);
			_str = new char[sz + 1];
			strcpy(_str, st);
			_size = sz;
			_capacity = sz;
		}
		void swap(string& str)
		{
			std::swap(_str, str._str);
			std::swap(_capacity, str._capacity);
			std::swap(_size, str._size);
		}
		string(const string& st)
		{
			string sv(st._str);
			swap(sv);
		}
		string operator=(string& st)
		{
			swap(st);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_capacity = _size = 0;
		}
		size_t size()
		{
			return _size;
		}
		size_t capacity()
		{
			return _capacity;
		}
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		iterator cbegin() const
		{
			return _str;
		}
		iterator cend() const
		{
			return _str + _size;
		}
		char operator[](size_t index)
		{
			return _str[index];
		}
		bool operator<(const string& s)
		{
			return strcmp(_str, s._str) < 0;
		}
		bool operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}
		bool operator<=(const string& s)
		{
			return *this < s || *this == s;
		}
		bool operator>(const string& s)
		{
			return !(*this < s || *this == s);
		}
		bool operator>=(const string& s)
		{
			return !(*this < s);
		}
		bool operator!=(const string& s)
		{
			return !(*this == s);
		}
		void resize(size_t n, char m = '?')
		{
			if (n <= _size)
				return;
			while (_size < n)
			{
				_str[_size++] = m;
			}
		}
		void reserve(size_t n)
		{
			if (n < _size)
				return;
			char* st = new char[n + 1];
			strcpy(st, _str);
			delete[] _str;

			_str = st;
			_capacity = n;
		}
		void clear()
		{
			_size = 0;
		}
		void push_back(char c);
		string& operator+=(char c);
		void append(const char* str);
		string& operator+=(const char* str);
		iterator insert(size_t pos, char c);
		iterator erase(size_t pos);
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};
}
namespace byte
{
	void string::push_back(char c)
	{
		if (_size == _capacity)
			reserve(_capacity == 0 ? 4 : 2 * _capacity);
		_str[_size++] = c;
		_str[_size] = '\0';
	}
	void string::append(const char* str)
	{
		reserve(_size + strlen(str) + 1);//提前开空间减少扩容带来的效率损耗
		for (int i = 0; str[i] != '\0'; i++)
		{
			push_back(str[i]);
		}
	}
	string& string::operator+=(char c)
	{
		push_back(c);
		return *this;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}
	ostream& operator<<(ostream& out, string& s)
	{
		for (auto vul : s)
		{
			out << vul;
		}
		return out;
	}
	istream& operator>>(istream& put, string& s)
	{
		s.clear();
		const size_t N = 256;
		char arr[N];
		char c;
		c = put.get();
		int i = 0;
		while (c != '\n' && c != ' ')
		{
			if (i != N - 1)
			{
				arr[i++] = c;
			}
			else
			{
				arr[i++] = '\0';
				s += arr;
				i = 0;
			}
			c = put.get();
		}
		if (i != 0)
		{
			arr[i] = '\0';
			s += arr;
		}
		return put;
	}
	string::iterator string::insert(size_t pos, char c)
	{
		if (_size == _capacity)
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		int end = _size;
		while (end != pos - 1)
		{
			_str[end + 1] = _str[end];
			end--;
		}
		_str[pos] = c;
		_size++;
		return begin() + pos + 1;
	}
	string::iterator string::erase(size_t pos)
	{
		int bin = pos;
		while (bin != _size)
		{
			_str[bin] = _str[bin + 1];
			bin++;
		}
		_size--;
		return begin() + pos;
	}
}
namespace byte
{
	void string_test1()
	{
		string x("123456");
		cout << x << endl;
		string k(x);
		cout << k << endl;
		string mstr;
		cin >> mstr;
		for (auto n : mstr)
		{
			cout << n;
		}
	}
	void string_test2()
	{
		//reserve
		string str("zxcvbnm");
		cout << "capacity:" << str.capacity() << endl;

		str.reserve(20);
		cout << "capacity:" << str.capacity() << endl;

		str.reserve(15);
		cout << "capacity:" << str.capacity() << endl;

		str.reserve(3);
		cout << "capacity:" << str.capacity() << endl;

		//resize
		str.resize(10, '0');
		cout << "size:" << str.size() << ' ' << str << endl;

		str.resize(3, '0');
		cout << "size:" << str.size() << ' ' << str << endl;
	}
	void string_test3()
	{
		string s("123456");

		s.push_back('x');
		cout << s << endl;

		s.append("vvv");
		cout << s << endl;

		s += "hhh";
		cout << s << endl;
	}

	void string_test4()
	{
		string s("12345678");

		s.erase(5);
		cout << s << endl;

		s.erase(2);
		cout << s << endl;

		s.insert(0,'0');
		cout << s << endl;
	}
}
int main()
{
	byte::string_test1();
	//byte::string_test2();
	//byte::string_test3();
	//byte::string_test4();
	return 0;
}

敲上瘾
关注
  • 87
    点赞
  • 踩
  • 80
    收藏
    觉得还不错? 一键收藏
  • 62
    评论
专栏目录
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
C++中string的模拟实现
09-01
在 C++ 的标准库中，`std::string` 提供了 `push_back()` 成员函数来实现这个功能，但在我们的模拟实现中，我们需要自己创建这个功能： ```cpp void String::Push_Back(char c) { if (_sz == _capacity) { // 如果...
【C++】string模拟实现
2303_79329831的博客
05-18 1885
本篇博客主要内容：实现string类的基本功能。string使用很快就讲完了，但是光会用string还不够，在面试中，面试官总喜欢让我们自己来模拟实现string类，包括string类的构造、拷贝构造、赋值运算符重载以及析构函数等等内容。所以，我认为string类的自实现还是有必要讲一下的。本篇博客主要介绍了string类常用接口的实现，包括默认成员函数，迭代器，字符和字符串的插入删除等等内容。♥STLC++
C++ [STL之string模拟实现]
ARMCSKGT的博客
05-19 5625
前面我们介绍了STL容器string的部分接口使用，有了string使我们对字符串的操作如鱼得水，其实string不止于使用方便，其实现也有许多我们值得学习的地方，本节将为您介绍string常用接口的代码实现！
⚡【C++要笑着学】(17) 模拟实现 string：深浅拷贝 | string 模拟实现 | 传统写法与现代写法
有道无术, 术尚可求。有术无道, 止于术。
05-07 4355
本章将正式介绍深浅拷贝，在模拟实现 string 的同时带着去理解深浅拷贝。我们模拟实现 string类不是为了造更好的轮子，而是为了去学习它，理解它的本质！你自己造一次，心里会更清楚，也有利于加深对 string 的理解。...
string的模拟实现
2401_83427936的博客
07-09 1978
分情况：//resize的模拟实现,可以删除数据，也可以扩容,不缩容,当_capacity为15，_size为10时。//resize(8)就是删除数据(删除两个),resize(12)就是插入数据,resize(18)就是扩容。15find的模拟实现,从pos位置找一个字符,返回下标位置。14erase的模拟实现,pos位置后删除len个字符。12insert的模拟实现,pos位置插入字符串。20resize的模拟实现,可以删除数据。16find的模拟实现,找字符串。30>>的模拟实现,流插。
『C++成长记』string模拟实现
小王又困了的博客
07-08 2663
本篇我们将为大家介绍string常用接口的模拟实现。
使用String模拟大数加减乘除（除法和取余待补充）
xiaoyi357的博客
04-10 2863
加减：模拟手工计算过程。 乘：模拟手工计算过程（乘数B的每一位数字和乘数A相乘的时候使用连续n次加法进行模拟） 除：连续做减法，直到差值出现负号 （注：代码未经过充分测试，重点是记录下思想）   Java代码如下：   import java.math.BigInteger; public class Solution { // 将string转化为指定的长度 public ...
【C++初阶】string模拟实现
weixin_74967884的博客
05-13 1982
本章节详细的讲解了string模拟实现。
【C++】string的模拟实现
学了就忘是正常现象
11-16 2698
C++中string类的模拟实现。
C++string类模拟实现
weixin_59112191的博客
04-27 1353
ssssss
【C++】string类的模拟实现
m0_62179366的博客
08-15 622
string类的模拟实现
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
String各个接口模拟实现
08-27
String各个接口模拟实现
string类的模拟实现
04-29
string类的模拟实现
自己模拟写C++中的String类型实例讲解
08-29
但是，在这里，我们将模拟实现一个自己的String类型，来展示C++中类的设计和实现。 构造函数 在我们的String类型中，我们定义了多个构造函数，包括： * 默认构造函数`String()`：用于创建一个空的字符串对象 * ...
javascript模拟实现C# String.format函数功能代码
10-26
总的来说，这个模拟实现的`String.format`函数为JavaScript提供了一种类似于C#的字符串格式化能力，允许开发者更方便地构建和操作字符串，特别是在需要动态替换字符串中的变量时。虽然这个实现相当基础，但足以满足...
C++ string类的模拟实现
最新发布
08-11
C++ string类的模拟实现
模拟实现string类深浅拷贝
01-08
从构造，析构以及拷贝构造的方面理解string类的底层实现。 源代码获取： https://github.com/akh5/C-/blob/master/STL/Mystring.cpp string的底层通过字符指针char*通过构造函数申请对应大小的空间，并将指针指向其...
模拟string类的封装
05-10
好的，以下是一个简单的模拟string类的封装示例： ```cpp #include <iostream> #include <cstring> class myString { private: char* str; int len; public: myString(const char* s = "") { len = std::strlen(s); str = new char[len + 1]; std::strcpy(str, s); } myString(const myString& other) { len = other.len; str = new char[len + 1]; std::strcpy(str, other.str); } ~myString() { delete[] str; } myString& operator=(const myString& other) { if (this != &other) { delete[] str; len = other.len; str = new char[len + 1]; std::strcpy(str, other.str); } return *this; } myString operator+(const myString& other) const { char* temp = new char[len + other.len + 1]; std::strcpy(temp, str); std::strcat(temp, other.str); myString result(temp); delete[] temp; return result; } bool operator==(const myString& other) const { return std::strcmp(str, other.str) == 0; } friend std::ostream& operator<<(std::ostream& os, const myString& s) { os << s.str; return os; } friend std::istream& operator>>(std::istream& is, myString& s) { char temp[1024]; is >> temp; s = myString(temp); return is; } }; int main() { myString s1("hello"); myString s2("world"); myString s3 = s1 + s2; std::cout << s3 << std::endl; std::cout << (s1 == s2) << std::endl; std::cout << (s1 == myString("hello")) << std::endl; std::cin >> s1; std::cout << s1 << std::endl; return 0; } ``` 在这个示例中，我们使用了一个char指针来存储字符串的内容，并使用了一个整数来存储字符串的长度。在构造函数中，我们使用了标准库函数strlen和strcpy来初始化字符串。在析构函数中，我们释放了分配的内存。在赋值运算符中，我们首先检查是否是自我赋值，然后释放当前分配的内存并复制新的字符串。在加法运算符中，我们创建了一个新的字符数组来存储两个字符串的连接，然后使用构造函数创建一个新的字符串对象并返回。在相等运算符中，我们使用标准库函数strcmp来比较两个字符串是否相等。最后，在流运算符中，我们使用标准库函数cin和cout来读取和输出字符串。
评论 62
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值