[C++](10)C++的string类如何实现？

最新推荐文章于 2024-04-04 19:55:45 发布
最新推荐文章于 2024-04-04 19:55:45 发布
阅读量748 收藏 14
点赞数 14
分类专栏： C++学习 文章标签： c++ 后端 算法 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CegghnnoR/article/details/125608481
版权

文章目录

构造析构及一些简单函数

string 类包含3个成员变量，_str 指针指向对应的字符串，_size 表示有效字符的个数（不包括\0）,_capacity 表示有效容量的大小（不包括存\0的空间）。

class String
{
public:

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

构造函数和析构函数：

String(const char* str = "") //构造函数提供全缺省的更好，默认传入空字符串。
	:_size(strlen(str))
	, _capacity(_size)
{
	_str = new char[_capacity + 1]; //+1是为了给\0开空间
	strcpy(_str, str);
}

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

c_str operator[] size capacity：

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

char& operator[](size_t pos) //记得传引用返回，支持修改
{
	assert(pos < _size);
	return _str[pos];
}
const char& operator[](size_t pos) const //也要提供const版本
{
	assert(pos < _size);
	return _str[pos];
}

size_t size() const
{
	return _size;
}

size_t capacity() const
{
	return _capacity;
}

深浅拷贝(拷贝构造、赋值重载)

拷贝构造我们可以不写吗，直接用编译器自动生成的？

答案是不可以，因为默认生成的完成的是浅拷贝，仅仅是把指针拷贝过去，导致两个对象的 _str 指向的是同一块空间，程序运行时会出现：1.析构两次 2.一个对象的修改影响另外一个

所以我们要写一个深拷贝，为新的对象在堆上开辟空间：

传统写法

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

赋值重载也面临同样的问题，同样要我们自己写深拷贝：

赋值是在两个对象都已经存在的情况下进行的，所以有些人容易想当然地以为直接 strcpy 就可以了，其实不然，如果被赋值的对象 _str 所指向的空间较小，要拷贝的内容就存不进去，如果空间较大，会造成浪费。

考虑到上述问题，这里可以简单粗暴地直接把原空间释放，重新开辟空间进行拷贝：

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

👆：记得考虑同一个对象自己给自己赋值的问题。

👆：先开空间后释放比先释放后开空间好。

现代写法、swap

拷贝构造

先完成成员函数swap

然后直接拿原对象里的 _str 去构造一个 tmp 对象，然后对 tmp 对象“夺舍”。

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

String(const String& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	String tmp(s._str);
	swap(tmp);
}

👆注意：交换前应该先初始化，否则 tmp 拿到的 _str 指针是随机值，析构时会出错

赋值重载

同样的思路：

String& operator=(const String& s)
{
	if (this != &s)
	{
		String tmp(s._str);
		swap(tmp);
	}
	return *this;
}

其实传值传参就是现成的 tmp，代码还可以写得更简洁：

String& operator=(String s)
{
    swap(s);
    return *this;
}

reserve、insert、push_back、append、+=

为了方便扩容，我们先写reserve

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

insert 插入一个字符，要注意检查是否需要扩容，这里采用2倍扩容：

String& insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
		reserve(_capacity == 0 ? 4 : _capacity * 2);
    
	for (size_t end = _size + 1; end >= pos + 1; --end)
	{
		_str[end] = _str[end - 1];
	}
	_str[pos] = ch;
	++_size;
	return *this;
}

👆：传返回值是为了模仿标准库，实际没什么用。

👆：这里的插入算法如果写成下列形式可能会出现死循环：

for (size_t end = _size; end >= pos; --end)
{
    _str[end + 1] = _str[end];
}

👆：因为我们用的是 size_t (无符号整型)，当 pos 为0(头插)时，end < 0 的终止条件无法达成，形成死循环

insert 插入一个字符串：

插入字符串和插入字符不同，插入字符串的扩容要特别计算一下，因为对于插入字符串来说，无脑2倍扩不一定够：

String& insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
		reserve(_size + len);

	for (size_t end = _size + len; end > pos + len - 1; --end)
	{
		_str[end] = _str[end - len];
	}
	strncpy(_str + pos, str, len);
	_size += len;
	return *this;
}

剩下的函数直接复用 insert 即可：

void push_back(char ch)
{
    insert(_size, ch);
}
void append(const char* str)
{
    insert(_size, str);
}
String& operator+=(char ch)
{
    insert(_size, ch);
    return *this;
}
String& operator+=(const char* str)
{
    insert(_size, str);
    return *this;
}

erase

首先定义一个静态成员变量npos，类内声明，类外定义。

class String
{
    //...
private:
	//...
	const static size_t npos;
};
const size_t String::npos = -1;

erase的实现，分两种情况：

  1. 从 pos 位置开始，删到最后，这种情况直接把 pos 位置的值设为 \0 即可
  2. 从 pos 位置开始，没有删到最后，那就要把后面的往前移
void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len == npos || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (size_t begin = pos + len; begin <= _size; ++begin)
		{
			_str[begin - len] = _str[begin];
		}
		_size -= len;
	}
}

resize

void resize(size_t n, char ch = '\0')

分三种情况：

  1. n > capacity：扩容并将字符追加至n个
  2. size < n < capacity：不扩容，直接将字符追加至n个
  3. n < size：不扩容，缩减字符至n个
void resize(size_t n, char ch = '\0')
{
	if (n < _size)
	{
		_size = n;
		_str[_size] = '\0';
	}
	else
	{
		if (n > _capacity)
			reserve(n);
		for (size_t i = _size; i < n; ++i)
		{
			_str[i] = ch;
		}
		_size = n;
		_str[_size] = '\0';
	}
}

比较运算符重载(非成员函数)

字符串比较直接用 strcmp，先写 < 和 == ，其他的复用即可。

bool operator<(const String& s1, const String& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const String& s1, const String& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const String& s1, const String& s2)
{
	return s1 < s2 || s1 == s2;
}
bool operator>(const String& s1, const String& s2)
{
	return s2 < s1;
}
bool operator>=(const String& s1, const String& s2)
{
	return !(s1 < s2);
}
bool operator!=(const String& s1, const String& s2)
{
	return !(s1 == s2);
}

迭代器

string 的迭代器其实就是指针：

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

使用迭代器遍历：

void test_string5()
{
	String s1("hello world");
	String::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << ' ';
		++it;
	}
	cout << endl;
}
//结果：h e l l o   w o r l d

有了迭代器，范围for也就可以用了，因为范围for的底层实现其实就是迭代器：

void test_string5()
{
	String s1("hello world");
	for (auto& ch : s1)
	{
		cout << ch << ' ';
	}
	cout << endl;
}
//结果：h e l l o   w o r l d

find

查找字符：

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

查找字符串，用 strstr：

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

流插入、流提取运算符重载、clear

为了保证 cout 是第一操作数，流插入运算符重载要实现在类外面。

通过 c_str 函数，我们也不需要访问私有成员变量，也就不需要设置友元函数。

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

注意：不能把范围for写成 out << s.c_str() 。因为如果字符串中间有\0，这种写法打印到\0就结束了

如下，两种方式的结果是不同的：

void test_string7()
{
	String s("hello");
	s += '\0';
	s += " world";
    
	cout << s.c_str() << endl;
	//结果：hello
	for (auto& ch : s)
	{
		cout << ch;
	}
	cout << endl;
    //结果：hello world
}

流提取之前需要把原有数据清空，所以先实现 clear：

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

流提取：

一个字符一个字符地读取，遇到空格或换行符停止。

in.get() 用来读取空格和换行符。

istream& operator>>(istream& in, String& s)
{
    s.clear();
	char ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

如果输入的字符串很长，频繁+=的扩容有一点影响效率，优化版本：

给一个大小为128的缓冲数组，满了再+=

istream& operator>>(istream& in, String& s)
{
    s.clear();
	char ch;
	ch = in.get();
	char buff[128] = { 0 };
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			s += buff;
			memset(buff, '\0', 128);
			i = 0;
		}
		ch = in.get();
	}
	s += buff;
	return in;
}

完整代码

#pragma once
#include <iostream>
#include <cassert>
using namespace std;

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 = "")
		:_size(strlen(str))
		, _capacity(_size)
	{
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}

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

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

	String(const String& s)
		:_str(nullptr)
		, _size(0)
		, _capacity(0)
	{
		String tmp(s._str);
		swap(tmp);
	}

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

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

	//String& operator=(const String& s)
	//{
	//	if (this != &s)
	//	{
	//		String tmp(s._str);
	//		swap(tmp);
	//	}
	//	return *this;
	//}

	String& operator=(String s)
	{
		swap(s);
		return *this;
	}

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

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

	size_t size() const
	{
		return _size;
	}

	size_t capacity() const
	{
		return _capacity;
	}

	String& operator+=(const char* str)
	{
		insert(_size, str);
		return *this;
	}

	String& operator+=(char ch)
	{
		insert(_size, ch);
		return *this;
	}

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

	void resize(size_t n, char ch = '\0')
	{
		if (n < _size)
		{
			_size = n;
			_str[_size] = '\0';
		}
		else
		{
			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)
	{
		insert(_size, ch);
	}
    
	void append(const char* str)
	{
		insert(_size, str);
	}

	String& insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size == _capacity)
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		for (size_t end = _size + 1; end >= pos + 1; --end)
		{
			_str[end] = _str[end - 1];
		}
		_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);

		for (size_t end = _size + len; end > pos + len - 1; --end)
		{
			_str[end] = _str[end - len];
		}
		strncpy(_str + pos, str, len);
		_size += len;
		return *this;
	}

	void erase(size_t pos, size_t len = npos)
	{
		assert(pos < _size);
		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			for (size_t begin = pos + len; begin <= _size; ++begin)
			{
				_str[begin - len] = _str[begin];
			}
			_size -= len;
		}
	}

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

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

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

private:
	char* _str;
	size_t _size;
	size_t _capacity;
	const static 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)
//{
//	char ch;
//	ch = in.get();
//	while (ch != ' ' && ch != '\n')
//	{
//		s += ch;
//		ch = in.get();
//	}
//	return in;
//}

istream& operator>>(istream& in, String& s)
{
	s.clear();
	char ch;
	ch = in.get();
	char buff[128] = { 0 };
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			s += buff;
			memset(buff, '\0', 128);
			i = 0;
		}
		ch = in.get();
	}
	s += buff;
	return in;
}

bool operator<(const String& s1, const String& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const String& s1, const String& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const String& s1, const String& s2)
{
	return s1 < s2 || s1 == s2;
}
bool operator>(const String& s1, const String& s2)
{
	return s2 < s1;
}
bool operator>=(const String& s1, const String& s2)
{
	return !(s1 < s2);
}
bool operator!=(const String& s1, const String& s2)
{
	return !(s1 == s2);
}
世真
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中实现继承string类的MyString类的步骤
09-02
主要介绍了C++中实现继承string类的MyString类的步骤,其中的要点是要实现运算符的重载,需要的朋友可以参考下
C++重载相等运算符operator==的两种方式
斧冰
09-02 1万+
最近复习了一下C++的一些基础知识，发现之前理解得不够深刻，或者当时只是简单过了一遍，复习的时候，有了一些新的收获。闲言少叙，书归正文： 问题： C++的重载相等运算符operator==可以写成类成员函数，也可以写成全局普通函数，请问这对于同一个类型的两种重载相等运算符可以同时存在么？如何可以，那么它们的调用优先顺序是怎么样的？ 我们还是用一个例子来说明： #include <iostream> class Person { private: int m_age; public: Per
C++基础---string类的operator==/operator!=/operator</operator<=/operator>/operator>=/compare
Catherine的笔记
09-03 2459
1. string中operator==/operator!=/operator< /operator<=/operator>/operator>=/compare 1.1 bool operator== 原型：bool operator== (const string& lhs, const string& rhs) noexcept; 说明： 比较string型字符串lhs与string型字符串rhs是否相等
c++-----string类及模拟实现———字符串
最新发布
2301_80687320的博客
04-04 651
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。一、string是什么？1. string是表示字符串的字符串类2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
【STL之前】[C++] string类 模拟实现 及 框架分析 ~
七月.cc的博客
10-31 238
上篇文章中介绍了 C++的 string类 及 string类的接口 本篇文章着重 模拟实现 string类 及其各接口
C++运算符、继承
zillll的博客
04-19 326
一、C++运算符重载“==” ①不允许用户自定义新的运算符，只能对已有的运算符进行重载 ②重载运算符不能改变运算符操作数的个数 ③不能改变运算符的优先级 ④不能改变运算符的结合性 ⑤不能有默认的参数 #include<iostream> using namespace std; class CStudent { private: string pname; int page; public: CStudent(string name,int age)
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4728
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
C++String类基础实现
02-14
对string类的基本功能进行复现，找到了一些错误和c++编程中的细节问题，都在此记录下来。MyString中实现了基本的构造函数、析构函数，重载了常用符号，并且给出了一些常用函数的实现。 供大家学习参考
C++简单String类的实现
12-22
我跟很多童鞋一样，目前也在学习C++中，昨天正在学习has-a关系中的包含时，例题是将string类包含的，因为是小白嘛，嘿嘿，为了更深的理解包含以及其他相关问题，果断上机边敲代码边理解咯，既然用到了string类，自己...
详解C++的String类的字符串分割实现
01-20
详解C++的String类的字符串分割实现 功能需求，输入一个字符串“1-2-3”切割出“1”、“2”、“3”。在Java下直接用String的split函数就可以了。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类的模拟实现
bit_zyx的博客
07-27 619
1、基本成员变量 2、默认成员函数 构造函数 析构函数 拷贝构造函数（深拷贝） 赋值运算符重载（深拷贝） 3、容量与大小相关函数 size capacity 4、字符串访问相关函数 operator[ ]重载 迭代器 5、增加的相关函数接口 reserve扩容 resize push_back追加字符 ......
C/C++编程笔记：如何在C++中标记字符串？四种方法告诉你
致力于C语言C++知识分享！
02-05 973
标记字符串表示相对于某些定界符分割字符串。有很多标记字符串的方法。在本文中，将对其中的四个进行说明。 使用stringstream 一个字符串流与允许你从字符串，就好像它是一个流中读取流的字符串对象关联。 以下是C ++实现： 使用strtok（） char * strtok（char str []，const char * delims）; C++： strtok（）的另一个示例（C）： 使用strtok_r（） 就像C语言中的strtok（）函数一样，strtok_r.
上标、下标和引用
weixin_33965305的博客
12-04 312
上标：… 下标：… 引用:
【C++】string 类的实现
honortech的博客
05-03 899
【C++】string 类的实现
C++ STL：string类的模拟实现
weixin_43908419的博客
03-14 570
本文介绍了C++ STL库中string类的模拟实现
C++实现string类
cliu1_16的博客
01-25 393
默认构造函数中，为ptr申请一个字节的堆内存，这样任何情况下，ptr都不为nullptr，避免了ptr是否为nullptr的情况，在随时访问的时候，就可以少写很多if判断。
C++中的string类用法简介
热门推荐
liitdar的博客
08-21 30万+
string是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和c语言的字符串之间有着良好的接口。
c++string类实现难点
11-29
C++中的string类实现难点包括以下几个方面： 1. 内存管理：string类需要动态分配内存来存储字符串，因此需要实现内存管理机制，包括内存分配、释放、扩容等操作。 2. 拷贝构造和赋值运算符重载：string类需要实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

世真

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

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

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

打赏作者

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

抵扣说明：

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

余额充值