【C++】手撕string类（超实用！）

已于 2024-03-15 10:35:02 修改
阅读量1.6k 收藏 34
点赞数 44
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-03-09 11:23:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eristic0618/article/details/136566179
版权

前言

一、标准库中的string类

1.1 string类介绍

1.2 string的常用接口

1.2.1 常用的构造函数

1.2.2 容量操作接口

（1）size

（2）capacity 

（3）empty 

（4）clear 

（5）reserve 

（6）resize 

1.2.3 访问和遍历

（1）operator[] 

（2）迭代器 

（3）at 

（4）back

（5）front

（6）find

（7）rfind和npos

（8）c_str

1.2.4 修改字符串操作

（1）operator+=

（2）push_back

（3）append

（4）insert

（5）erase

（6）swap

（7）operator+

（8）getline

1.2.5 各种运算符重载函数

（1）operator>>和operator<<

（2）比较运算符

二、模拟实现string类

前言

学习string类之前，我们需要对STL库有一个简单的了解

STL（standard template library——标准模板库），是C++标准库的重要组成部分，不仅是一个可复用的组件库，还是一个包罗数据结构与算法的软件框架。

STL有六大组件：

一、标准库中的string类

1.1 string类介绍

string类是表示字符串的一个类，内部通常有三个成员变量：指向字符串的指针、字符串的有效元素个数和字符串的容量大小

char* _str;
size_t _size;
size_t _capacity;

我们通过string类中的成员函数（接口），就能对字符串进行各种操作

在使用string类时，必须包含头文件<string>和using namespace std;

1.2 string的常用接口

1.2.1 常用的构造函数

string();

默认构造函数，用于构造空的string类对象

例如：

void Test()
{
    string s1;
}
string(const char* s);

用一个常量字符串来构造string类对象

例如：

void Test()
{
    string s1("hello");
}
string(const string& s);

string类的拷贝构造函数

例如：

void Test()
{
    string s1("hello");
    string s2(s1);
}

1.2.2 容量操作接口

（1）size

size_t size() const;

返回字符串有效字符长度

string类中还有一个函数length和size的效果一样，最初只有length存在，为了和其他容器相同后面新增了size

例如：

（2）capacity 

size_t capacity() const;

返回字符串容量

例如：

（3）empty 

bool empty()  const;

 检测字符串是否为空串，为空返回true，否则返回false

例如：

（4）clear 

void clear();

用于清空有效字符，不改变字符串容量大小

例如：

（5）reserve 

void reserve(size_t n = 0);

为字符串预留空间

例如：

如果n比原容量小则不作改变

在vs上常常会开比n更大一些的空间

（6）resize 

void resize(size_t n);

void resize(size_t n, char c);

将有效字符的个数修改为n，并且如果n大于原来的_size，多出来的地方用字符c填充，不改变字符串容量大小

如果没有给出字符c，则用\0填充

例如：

1.2.3 访问和遍历

（1）operator[] 

char& operator[](size_t pos);

const char& operator[](size_t pos) const;

返回字符串中pos位置的字符

例如：

（2）迭代器 

iterator begin();

const_iterator begin() const;

iterator end();

const_iterator end() const;

迭代器，用于获取字符串第一个字符的位置和最后一个字符的下一个位置

例如：

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

reverse_iterator rend();

const_reverse_iterator rend() const;

反向迭代器，rbegin获取字符串最后一个字符的位置，rend获取字符串的第一个字符的前一个位置

例如：

需要注意，这里rit是加加而不是减减

范围for的底层实际上也是迭代器

（3）at 

char& at(size_t pos);

const char& at(size_t pos) const;

返回字符串中pos位置的字符的引用

例如：

（4）back

char& back();

const char& back() const;

返回字符串最后一个字符的引用

例如：

（5）front

char& front();

const char& front() const;

返回字符第一个字符串的引用

例如：

（6）find

size_t find(char c, size_t pos = 0) const;

从字符串的pos位置向后找字符c，返回该字符在字符串中的位置

例如：

（7）rfind和npos

size_t rfind(char c, size_t pos = npos) const;

static const size_t nops = -1

从字符串的pos位置向前找字符c，返回该字符在字符串中的位置

npos是string类中定义的一个静态成员变量，类型为无符号整型，值为-1，因为是无符号转换后变成整型的最大值，也就是4294967295（42亿多），当我们不给pos的值时按照缺省值执行，默认从字符串尾部开始找起

例如：

（8）c_str

const char* c_str() const;

按照C语言的格式返回字符串

例如：

在hello后面加上\0和字符串world，重载后的流插入操作符函数会按照size的大小来打印字符串

而打印c_str的返回值，会遇到\0就停下

1.2.4 修改字符串操作

（1）operator+=

string& operator+=(const string& str);

string& operator+=(const char* s);

string& operator+=(char c);

在字符串后追加一个字符串或字符

例如：

（2）push_back

void push_back(char c);

在字符串后尾插一个字符c

例如：

（3）append

string& append(const string& str);

string& append(const char* s);

string& append(const char* s, size_t n);

string& append(size_t n, char c);

用于在字符串后加一个字符串、一个字符串的前n个字符或n个字符c

例如：

（4）insert

string& insert(size_t pos, const string& str);

string& insert(size_t pos, const char* s);

string& insert(size_t pos, const char* s, size_t n);

string& insert(size_t pos, size_t n, char c);

iterator insert(iterator p, char c);

用于在字符串的pos位置插入一个字符串、字符串的前n个字符或n个字符c

还有迭代器版本的insert，用法是在p的位置插入字符c 

例如：

（5）erase

string& erase(size_t pos, size_t len = npos);

iterator erase(iterator p);

iterator erase(iterator first, iterator last);

用于在字符串的pos位置删除len个字符

迭代器版本的erase，在p的位置删除一个字符，或者删除 [ first , last ) 内的字符

例如：

（6）swap

void swap(string& str);

用于交换两个string类对象

string类中的swap函数相比标准库中的swap函数，交换string类对象的效率更高

例如：

（7）operator+

string operator+(const string& lhs, const string& rhs);

string operator+(const string& lhs, const char* rhs);

string operator+(const char* lhs, const string& rhs);

string operator+(const string& lhs, char rhs);

string operator+(char lhs, const string& rhs);

返回一个新构造的string类对象，其值是lhs和rhs的合并

例如：

（8）getline

istream& getline(istream& is, string& str, char delim);

istream& getline(istream& is, string& str);

用于字符串的输入

相比cin遇到空格就停止提取，我们可以给出分隔符delim，遇到delim才停止提取，如果没有给出，则遇到换行停止提取

例如：

1.2.5 各种运算符重载函数

（1）operator>>和operator<<

istream& operator>>(istream& is, string& str);

ostream& operator<<(ostream& os, const string& str);

用于string对象的流提取和流插入

例如：

（2）比较运算符

各种比较运算符的重载函数，这里就不赘述了

用于比较两个字符串的对应位置的ASCII码值大小

例如：

二、模拟实现string类

知道了string类中各种常用接口的用法后，我们就可以开始自己手撕一个自己的string类了

为了不和标准库中的string类冲突，我们可以开一个自己的命名空间

完整代码如下：

namespace Eristic
{
	class string
	{
		friend ostream& operator<<(ostream& cout, const string& s);
		friend istream& operator>>(istream& cout, const string& s);
	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 = "")
			:_size(strlen(str))
		{
			_capacity = _size == 0 ? 3 : _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

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

		bool empty() const
		{
			size_t len = strlen(_str);
			return !len;
		}

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

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

		char& back()
		{
			return at(_size - 1);
		}

		const char& back() const
		{
			return at(_size - 1);
		}

		char& front()
		{
			return at(0);
		}

		const char& front() const
		{
			return at(0);
		}

		void resize(size_t n, char ch = '\0')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else if (n > _size)
			{
				if (n > _capacity)
				{
					reserve(n);
				}
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

		void push_back(char ch)
		{
			if (_size + 2 > _capacity)
			{
				reserve(_capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
			//insert(_size, ch); //或者直接复用
		}

		void push_back(const char* str)
		{
			append(str);
		}

		void append(const char* str)
		{
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size + 1 > _capacity)
			{
				reserve(_capacity * 2);
			}
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			_size++;
			return *this;
		}

		string& 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 + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

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

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_capacity, s._capacity);
			std::swap(_size, s._size);
		}

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

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

		size_t find(const string& s, size_t pos = 0) const
		{
			assert(pos < _size);
			char* p = strstr(_str + pos, s._str);
			if (p == nullptr)
			{
				return npos;
			}
			return p - _str;
		}

		size_t find(const char* str, size_t pos = 0) const
		{
			assert(pos < _size);
			char* p = strstr(_str + pos, str);
			if (p == nullptr)
			{
				return npos;
			}
			return p - _str;
		}

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

		string& operator+=(const string& s)
		{
			push_back(s._str);
			return *this;
		}

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

		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;
		}

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

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

		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);
		}

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

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

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

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

		static const 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 ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i != 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}
}

如有错误，欢迎在评论区指出

完.

阿瑾0618
关注
专栏目录
【C++杂货铺】string使用指南
春人.的博客
08-03 3808
本篇文章介绍了C++中string类的用法，对一些常用的接口进行了详细的介绍，其中包括用法介绍、特性介绍、以及注意事项。
【华为OD技术面试手撕真题】12、二进制求和 | 手撕真题+思路参考+代码解析（C & C++ & Java & Python & JS）0ms耗时
KJ.JK
08-03 5428
【华为OD面试手撕真题】12、二进制求和 | 手撕真题+思路参考+代码解析（C & C++ & Java & Python & JS）0ms 华为od机试真题，华为OD技术二面，华为od机考，华为od手撕真题，华为od技术二面，华为od机试，华为OD机试的高频手撕代码题，华为od八股文
C++面试题：手撕String类
weixin_44537258的博客
04-07 636
对于一个String类要自己写构造析构，避免浅拷贝等内存泄漏问题 class String{ public: String(const char* str = nullptr); //普通构造函数 String(const String& other); //拷贝构造函数 String& operator=(const String& other); //拷贝赋值函数 ~String(); //析构函数 private: char* m_dat
c++ string类的实现 手撕string类
renzemingcsdn的博客
02-11 613
要求 要求通过动态数组实现，不能分配静态定长内存。 要求实现如下函数 要求事情内存时不能使用new华为delete，new char[n_bytes] → new_char_array(int n_bytes), and delete[] p → delete_char_array(char *p)。 实现 String.cpp #include "String.h" int String::strlen(const char *s) { int len = 0; for (;
【25届秋招备战C++】超高频面试手撕代码题
最新发布
weixin_44791229的博客
08-25 1108
快指针和慢指针同时开始，每次快指针走两步，慢指针走一步，设共a+b个节点，且第a+1个节点即为环的入口，那么快慢指针第一次相遇时二者必然差n个环，即快指针走的步数f-慢指针走的步数s=n*b，解题思路：类似于元素交换，新建一个链表存储当前链表下一节点，更改当前链表的下一节点为上一节点（初始为空指针），给上一节点赋值为当前节点，当前节点接着赋值为暂存的下一节点。解题思路：引入第三个链表实现即可，同时为了方便处理新链表的头节点，引入了一个cur指针初始化指向一个新的链表节点，节点值为0，避免头节点处理。
C++手撕string(构造+析构+拷贝+右值拷贝)
xizi_ghq的博客
12-28 601
#include<bits/stdc++.h> using namespace std; class sstring{ public: sstring(const char *p=nullptr){ cout<<"sstring(const char *p=nullptr)"<<endl; if(p==nullptr){ _p=new char[1]; _p[0]='\0'; .
【C++】手撕string（string的模拟实现）
小羊study_sheep的博客
09-26 2548
快来和我手撕string！
C++面试题--手写String类
weixin_36299192的博客
04-02 911
这个题目是面试中很常见的，对考查C++基础知识来说非常好。 首先我们应该想到，一个类最基本的构成有构造函数，析构函数。 对于这个题目，字符串类，我们先写出它类的定义 含有指针成员变量的类：我们必须重载他的构造函数，析构函数，以及赋值函数。 class String { public : String(const char *str = NULL);//重载构造函数 String(const S...
【手撕STL】string类
AI_ELF的博客
12-30 1216
string类标准库中的string类string类string类的常用接口说明三级目录 标准库中的string类 string类 字符串是表示字符序列的类 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。 string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型 string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_tra
STL 容器详解——string 类
qq_61500888的博客
06-06 3385
带你一命通关C++的STL容器 十分钟手撕 string 类
手撕一个string类（c++）
weixin_53344209的博客
04-04 478
不然的话就先清空自己的m_data，因为自己已经初始化了，再strcpy复制数据，返回this指针表示对象。可以返回一个新对象，由于是局部对象，所以不能返回引用，不然内存安全问题了。由于要返回对象本身，所以先delete原来的数据，再m_data = newData。正因为有指针成员，所以必须自定义拷贝构造函数，因为默认的是浅复制，会造成空悬指针。析构函数，标准形式，先清空自己的数据空间，再把指针置空。扩展：重载+、重载+=、重载==、重载[]、重载
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
c++笔试和面试常见的手撕代码题，用两个队列实现堆栈
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
手写C++ string类
weixin_45867382的博客
05-31 1284
手写的 string 类包含构造函数、拷贝构造函数、移动构造函数、拷贝赋值函数、析构函数以及重载输出操作符。
现场面试-手撕代码-c/c++
weixin_40291215的博客
09-13 938
现场面试常见的手写代码基础题 冒泡排序（O（n2））（升序） void BubbleSort(int *inputData, int length) { for (int i = 0; i &lt; length; i++) { for (int j = 0; j &lt; length-i-1; j++) { if (i...
【C++】---模拟实现string类
L19002S的博客
10-31 3088
【C++】–模拟实现string类 引言：在面试中，很有可能面试官一上去就会让你手撸代码，写一个简单的string类，这也是一个点击率超高的考点，那么我们今天来探索一下什么是string类，以及如何实现string类。 一、String类的六大默认成员函数 1.构造函数 String(const char* str = "")//构造函数 { _size = strlen(str); ...
手撕代码: C++实现数据的序列化和反序列化
红军不怕远征难，万水千山只等闲
04-24 2608
在C++应用程序中，经常会涉及到对一些数据进行序列化和反序列化的处理。序列化可以将一个对象转换为一串字节流，这样就可以将其存储在硬盘上或者通过网络传输到其他设备上。而反序列化则是将这些字节流解析成原始的对象。 在Qt中，数据的序列化和反序列化可以使用QDataStream类来完成。QDataStream是一个方便的Qt类，它可以将基本数据类型、Qt数据类型以及用户定义的数据类型都进行序列化和反序列化。在使用QDataStream进行序列化时，需要指定一个QIODevice类的子类（例如QF
C/C++笔试面试手撕代码注意事项
FlushHip
09-24 4213
算法思想是否正确 代码逻辑是否清晰明了 代码风格是否美观简洁 注释和变量命名 STL/C++11 不要雷同！ 算法正确这是最主要的点，如果算法都不对，就是直接0分了；代码逻辑要清晰明了，考虑问题要全面，逻辑一混乱，基本就是60分左右了；如果你的代码风格很丑，我基本是不会看的，又或者很简单的一个题，你写了一百多行代码，这我也是不会看的；如果你的算法不是常规的算法，建议最好写出注释，不然有些面试...
C++面试 常见手撕代码
zyj的写作区
10-08 3005
1、冒泡排序 #include &amp;amp;lt;iostream&amp;amp;gt; using namespace std; void swap(int &amp;amp;amp;a, int &amp;amp;amp;b){ int temp = a; a = b; b = temp; } void sort(int nums[], int num){ for (int i = 0; i &amp;amp;lt; nu
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值