C++初阶：string类的模拟自实现

执笔者5482024-03-19 14:55

目录

  • [1. 引子](#1. 引子)
  • [2. 自实现string类功能模块](#2. 自实现string类功能模块)
  • [3. string类功能模块的具体实现](#3. string类功能模块的具体实现)
    • [3.1 默认成员函数](#3.1 默认成员函数)
    • [3.2 遍历访问相关成员函数](#3.2 遍历访问相关成员函数)
    • [3.3 信息插入相关成员函数](#3.3 信息插入相关成员函数)
    • [3.4 信息删除](#3.4 信息删除)
    • [3.5 信息查找](#3.5 信息查找)
    • [3.6 非成员函数](#3.6 非成员函数)
    • [3.7 杂项成员函数](#3.7 杂项成员函数)
  • [4. 补充知识](#4. 补充知识)

1. 引子

  1. 通过对string类的初步学习，没有对知识进行较深度学习了解剖析，只是囫囵吞枣地学会其的使用方式。
  2. 仅仅掌握string类的使用方式，对我们熟练掌握使用STL的相关容器及其背后的深层知识是远远不够的。
  3. 因此，我们来通过模拟尝试自实现的方式，对string类背后的知识与编程思想做一个更深入的学习掌握。

2. 自实现string类功能模块

  1. 默认成员函数：构造，拷贝构造，析构，operator=运算符重载
  2. 杂类成员函数：size，c_str，swap，substr
  3. 遍历访问相关成员函数：operator[]，const_operator[]，iterator（迭代器）
  4. 信息插入，扩容相关成员函数：append，push_back，operator+=，reserve，insert
  5. 信息删除相关成员函数：erase
  6. 信息查找相关成员函数：find
  7. 非成员函数：operator+，<<，>>

3. string类功能模块的具体实现

3.1 默认成员函数

string类的结构，成员变量

cpp 复制代码 
class string
{
private:
	//指向存储数据地址的指针
	char* _str;
	//能够存储有效字符的容量
	int _capacity;
	//有效字符的长度
	int _size;
	
	//正常定义方式：类内声明，类外声明类域定义初始化

	//特殊定义方式
	const static size_t npos = -1;
};

1. 构造函数

  1. 字符串构造
    <1> 使用初始化列表的构造方式，初始化容量与size都需要使用strlen函数计算一遍字符串长度
    <2> strlen计算字符串长度的方式为暴力遍历法，多次调用会使得效率低下
    <3> 先用strlen初始化capacity，再使用capacity初始化其他两个成员变量的方式，会使得成员变量的定义方式变得死板
cpp 复制代码 
//字符串构造
string(const char* str)
{
	//开辟空间
	int len = strlen(str);
	_str = new char[len + 1];
	//拷贝
	strcpy(_str, str);
	//处理尾部
	_str[len] = '\0';
	_capacity = len;
	_size = len;
}
  1. 无参构造
    <1> 无参构造时，初始化str不能使用空指针，当我们使用流插入操作符对str的内容进行打印时，cout会将其自动默认为字符串进行打印，对其进行解引用，而对空指针进行解引用会出现bug
    <2> 无参构造时，不意味着指针为空，无参构造时只是有效字符的长度为0，因，我们可以在空间中存储一个'\0'字符进行标识
cpp 复制代码 
//无参构造，空字符串
string()
{
	_str = new char[1]{ '\0' };

	_capacity = 0;
	_size = 0;
}

2. 析构函数

cpp 复制代码 
~string()
{
	delete[] _str;
	_capacity = 0;
	_size = 0;
}

3. 拷贝构造函数

cpp 复制代码 
//string(const string& str)
//{
//	_str = new char[str._capacity + 1];
//	strncpy(_str, str._str, str._size);
//	
//	_size = str._size;
//	_capacity = str._capacity;
//
//	_str[_size] = '\0';
//}

string::string(const string& str)
{
	//现代写法
	string tmp(str._str);

	swap(tmp);
}

4. operator=运算符重载

cpp 复制代码 
//string& string::operator=(const string& str)
//{
//	//优化：
//	//参数变为string
//	//再将拷贝形参与当前string进行交换

//	char* tmp = new char[str._size + 1];
//	strcpy(tmp, str._str);

//	_size = str._size;
//	_capacity = str._capacity;

//	delete[] _str;
//	_str = tmp;

//	return *this;
//}

string& string::operator=(string str)
{
	//现代写法
	swap(str);

	return *this;
}

3.2 遍历访问相关成员函数

1. operator[]

  1. operator[]的访问方式需要支持普通string类与const修饰的string类的调用，因此，要进行重载两次
cpp 复制代码 
//普通string类调用
char& operator[](size_t pos)
{
	assert(pos < _size);
	
	return _str[pos];
}
//const修饰的string类调用
const char& operator[](size_t pos) const
{
	assert(pos < _size);

	return _str[pos];
}

2. iterator

cpp 复制代码 
typedef char* iterator;

iterator begin()
{
	return _str;
}

iterator end()
{
	//最后一个字符后一位
	return _str + _size;
}

3. const修饰的iterator

cpp 复制代码 
typedef const char* const_iterator;

const_iterator begin()const
{
	return _str;
}

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

4. 范围for的访问方式

  1. 此遍历方式的底层实现为，将迭代器的遍历方式进行替换，当迭代器线管函数的名与库中不同时，范围for的遍历方式也不能正常使用（err：Begin()）
cpp 复制代码 
for(auto e : s)
{
	cout << e;
}
cout << endl;

3.3 信息插入相关成员函数

1. 扩容成员函数reserve

  1. 将string类的空间容量进行调整，当指定参数大于当前空间容量时进行扩容，小于时不会进行缩容
cpp 复制代码 
//插入相关
void reserve(int size)
{
	if (size > _capacity  )
	{
		//申请一段额外的空间
		//失败抛异常
		char* tmp = new char[size + 1];

		//将值进行拷贝
		strncpy(tmp, _str, _size);

		//销毁原空间
		delete[] _str;

		//调整
		_str = tmp;
		_capacity = size;
	}
}

2. push_back

cpp 复制代码 
void push_back(const char& c)
{
	if (_capacity == _size)
	{
		reserve(_size + 1);
		_str[_size] = c;
		_size++;
		_str[_size] = '\0';
	}
}

3. append

  1. 拼接一串字符串
cpp 复制代码 
void append(const char* str)
{
	int len = strlen(str);
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}

	strncpy(_str + _size, str, len);

	_size += len;
	_str[_size] = '\0';
}
  1. 拼接参数string类的内容
cpp 复制代码 
void append(const string& s)
{
	int len = s.size();
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}

	strncpy(_str + _size, s.c_str(), len);

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

4. insert

  1. 给指定位置插入一个字符
cpp 复制代码 
//在pos位置插入一个字符
void insert(size_t pos, const char& c)
{
	assert(pos < _size);
	
	if (_size == _capacity)
	{
		reserve(_size + 1);
	}
	
	//当pos为0时
	int end = _size;
	//pos类型为size_t，比较时，end隐式类型转换为size_t类型
	//当插入位置为0时，会出现bug
	while (end >= (int)pos)
	{
		_str[end + 1] = _str[end];
		end--;
	}
	
	_str[pos] = c;
	
	_size++;
	_str[_size] = '\0';
}
  1. 给指定位置插入一串字符串
cpp 复制代码 
//在pos位置插入一串字符串
void insert(size_t pos, const char* str)
{
	assert(pos < _size);

	int len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	//当pos为0时
	int end = _size;
	while (end >= (int)pos)
	{
		_str[end + len] = _str[end];
		end--;
	}

	strncpy(_str + pos, str, len);
	_size += len;
	_str[_size] = '\0';
}

5. operator+=

  1. 在当前string类后拼接参数string类的内容
cpp 复制代码 
string& operator+=(const string& str)
{
	if (_size + str._size > _capacity)
	{
		reserve(_size + str._size + 1);
	}

	strncpy(_str + _size, str._str, str._size);
	
	_size += str._size;
	_str[_size] = '\0';

	return *this;
}
  1. 在当前string类后拼接参数字符串
cpp 复制代码 
string& string::operator+=(const char* str)
{
	append(str);

	return *this;
}
  1. 拼接字符（复用）
cpp 复制代码 
string& string::operator+=(const char c)
{
	push_back(c);

	return *this;
}

3.4 信息删除

1. erase

  1. 从指定下标开始，向后删除指定个元素
cpp 复制代码 
//在pos位置插入一串字符串
void string::erase(size_t pos, size_t len)
{
	assert(pos < _size);

	//直接添加'\0'
	if (len == npos || pos + len > _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		//连'\0'一起拷贝
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
}

3.5 信息查找

1. find

  1. 从指定位置开始向后查找指定的字符
cpp 复制代码 
size_t find(const char& c, size_t pos = 0)
{
	assert(pos < _size);
	int i = pos;
	while (i < _size)
	{
		if (_str[i] == c)
		{
			return i;
		}
		i++;
	}

	return npos;
}
  1. 从指定位置开始，向后查找指定字符串
cpp 复制代码 
//查找字符串
size_t find(const char* str, size_t pos = 0)
{
	assert(pos < _size);
	char* cur = strstr(_str + pos, str);
	if (cur == nullptr)
	{
		return npos;
	}

	return cur - _str;
}

3.6 非成员函数

1. operator<<

  1. 流插入操作符重载，非成员函数，非友元，非静态成员函数
  2. 间接访问方式，不直接访问成员变量
cpp 复制代码 
ostream& operator<<(ostream& out, const string& str)
{
	//将每一个字符的拷贝插入到流中
	for (auto e : str)
	{
		out << e;
	}

	return out;
}

2. operator>>

  1. 流提取操作重载
cpp 复制代码 
istream& operator>>(istream& in, string& str)
{
	str.clear();

	char data[128] = "";
	//从流中获取字符
	char ch = in.get();
	int i = 0;
	while (ch != ' ' && ch != '\n')
	{
		data[i++] = ch;
		//溢出，截断
		if (i == 127)
		{
			data[i] = '\0';
			str += data;
			break;
		}

		ch = in.get();
	}

	if (i < 127)
	{
		data[i] = '\0';
		str += data;
	}

	return in;
}

3. operator+

  1. 返回一个临时的string类，其内容为当前string类与参数字符串拼接
cpp 复制代码 
string operator+(const string& str1, const string& str2)
{
	string tmp(str1);

	return tmp += str2;
}

string operator+(const string& str1, const char* str2)
{
	string tmp(str1);

	return tmp += str2;
}

4. swap

  1. 非成员函数swap，交换两个string类，优先级高于算法库中swap模板
cpp 复制代码 
void swap(string& str1, string& str2)
{
	//会生成中间变量
	string tmp = str1;
	str1 = str2;
	str2 = tmp;
}

3.7 杂项成员函数

1. c_str

  1. 以C语言类型的字符串方式返回string类的内容
cpp 复制代码 
const char* c_str() const
{
	return _str;
}

2. substr

  1. 返回内容为当前string类子串的string类
cpp 复制代码 
string string::substr(size_t pos, size_t len)
{
	assert(pos < _size);

	string tmp;
	int end = pos + len;
	if (pos + len > _size || len == npos)
	{
		end = _size;
	}

	//先预先扩容
	reserve(len + 1);
	for (int i = pos; i < end; i++)
	{
		tmp += _str[i];
	}

	return tmp;
}

3. swap

  1. 成员函数swap，交换两者数据指针，效率高
cpp 复制代码 
void swap(string& str)
{
	//直接调用库函数
	std::swap(_str, str._str);
	std::swap(_capacity, str._capacity);
	std::swap(_size, str._size);
}

4. 补充知识

  1. Linux下g++编译器对于string类的实现
    <1>string类的结构
    <2>拷贝构造方式：浅拷贝 + 引用计数 + 写时拷贝

1. Linux环境g++编译器string类的结构

  1. string类的成员函数只有一个指针（8字节）,指针指向的结构，如下图：


2. 引用计数与浅拷贝

  1. <1> 当我们进行拷贝构造时，先只进行浅拷贝，使得拷贝而得的新对象的数据指针与原对象指向同一块数据空间
    <2> 当新创建的对象的被调用数据需要修改时再进行拷贝，而后修改（写实拷贝）
    <3> 当一块数据空间的引用计数清零时，才会进行指针的销毁
    <4> 这样的拷贝方式，如果拷贝构造得到对象不被修改时会提高效率，较少开销
相关推荐
凤枭香1 分钟前
Python OpenCV 傅里叶变换
开发语言·图像处理·python·opencv
ULTRA??5 分钟前
C加加中的结构化绑定（解包，折叠展开）
开发语言·c++
远望清一色21 分钟前
基于MATLAB的实现垃圾分类Matlab源码
开发语言·matlab
confiself31 分钟前
大模型系列——LLAMA-O1 复刻代码解读
java·开发语言
凌云行者40 分钟前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
XiaoLeisj42 分钟前
【JavaEE初阶 — 多线程】Thread类的方法＆线程生命周期
java·开发语言·java-ee
凌云行者44 分钟前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl
杜杜的man1 小时前
【go从零单排】go中的结构体struct和method
开发语言·后端·golang
幼儿园老大*1 小时前
走进 Go 语言基础语法
开发语言·后端·学习·golang·go
半桶水专家1 小时前
go语言中package详解
开发语言·golang·xcode
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解