STL讲解(二)—string类的模拟实现

文章目录

一、前言
- [1.1 string类各函数接口总览](#1.1 string类各函数接口总览)
- [1.2 前情提要](#1.2 前情提要)
二、模拟实现string类
- [2.1 成员函数(Member functions)](#2.1 成员函数(Member functions))
- - [2.1.1 构造函数](#2.1.1 构造函数)
  - [2.1.2 拷贝构造函数](#2.1.2 拷贝构造函数)
  - [2.1.3 赋值运算符重载](#2.1.3 赋值运算符重载)
  - [2.1.4 析构函数](#2.1.4 析构函数)
- [2.2 元素访问(Element access)](#2.2 元素访问(Element access))
- - [2.2.1 operator[ ]](#2.2.1 operator[ ])
  - [2.2.2 迭代器(Iterator)](#2.2.2 迭代器(Iterator))
- [2.3 容量(Capacity)](#2.3 容量(Capacity))
- - [2.3.1 size](#2.3.1 size)
  - [2.3.2 capacity](#2.3.2 capacity)
  - [2.3.3 clear](#2.3.3 clear)
  - [2.3.4 empty](#2.3.4 empty)
  - [2.3.5 reserve](#2.3.5 reserve)
  - [2.3.6 resize](#2.3.6 resize)
- [2.4 修改器(Modifiers)](#2.4 修改器(Modifiers))
- - [2.4.1 push_back](#2.4.1 push_back)
  - [2.4.2 append](#2.4.2 append)
  - [2.4.3 +=](#2.4.3 +=)
  - [2.4.4 insert](#2.4.4 insert)
  - [2.4.5 erase](#2.4.5 erase)
  - [2.4.6 swap](#2.4.6 swap)
- [2.5 字符串操作(String Operations)](#2.5 字符串操作(String Operations))
- - [2.5.1 find函数](#2.5.1 find函数)
  - [2.5.2 rfind函数](#2.5.2 rfind函数)
  - [2.5.3 substr](#2.5.3 substr)
- [2.6 非成员函数重载](#2.6 非成员函数重载)
- - [2.6.1 关系运算符(relational operators)](#2.6.1 关系运算符(relational operators))
  - [2.6.2 流插入 operator<<](#2.6.2 流插入 operator<<)
  - [2.6.3 流提取 operator>>](#2.6.3 流提取 operator>>)
  - [2.6.4 getline](#2.6.4 getline)
三、string类的模拟实现整体代码
- [3.1 string.h](#3.1 string.h)
- [3.2 string.cpp](#3.2 string.cpp)
- [3.3 test.cpp](#3.3 test.cpp)
四、写时拷贝(了解)

一、前言

在经过漫长的类和对象与STL 学习之后，对于 STL中的 string类有了一个基本的认识，本模块呢，我将会带大家一起从 0~1去模拟实现一个STL库中的 string类，当然模拟实现的都是一些常用的接口，以便于让大家更好的巩固之前学习过的缺省参数、封装、类中的6大默认成员函数等

1.1 string类各函数接口总览

cpp 复制代码

class string
	{
	public:
		// ...

		typedef char* iterator;             // 迭代器某种意义上就是 指针
		typedef const char* const_iterator;


	//默认成员函数
		//string();   //无参构造函数
		//string(const char* str); //带参构造函数
		string(const char* str = "");//二合一构造函数,常量字符串默认末尾是有 ' \0 '

		const char* c_str() const;  // 添加c_str()函数声明
		
		string(const string& s); //拷贝构造函数
		void swap(string& s);    //交换函数
		string& operator=(const string& s);//赋值运算符重载
		~string();//析构函数

	//元素访问
		char& operator[](size_t pos);//下标访问-可读可写
		const char& operator[](size_t pos) const;//下标访问-可读不可写
		iterator begin();//迭代器的实现-可读可写
		iterator end();
		const_iterator begin() const;//迭代器的实现-可读不可写
		const_iterator end() const;
		


	//容量
		size_t size() const;//获取当前字符串的有效长度
		size_t capacity() const;//获取字符串当前的容量
		void clear();//清除当前对象的数据
		bool empty() const;//判断对象中是否有数据
		void reserve(size_t newCapacity);//扩容(修改_capacity)
		void resize(size_t newSize, char c = '\0');//改变大小

	//修改器
		void push_back(char ch);//追加一个字符
		void append(const char* s);//追加一个字符串
		string& operator+=(char ch);//+=一个字符
		string& operator+=(const char* s);//+=一个字符串
		void insert(size_t pos, size_t n, char ch);//在pos位置插入n个字符
		void erase(size_t pos, size_t len = npos);//从pos位置删除长度为len的字符串

	//字符串操作
		size_t find(char ch, size_t pos) const;//寻找一个字符
		size_t find(const char* s, size_t pos) const;//寻找一个字符串
		size_t rfind(char ch, size_t pos = npos)const;//反向寻找一个字符
		size_t rfind(const char* s, size_t pos = npos)const;//反向寻找一个字符串
		string substr(size_t pos, size_t len);//从字符串中提取子串

	//非成员函数重载
		bool operator<(const string& s)const;//函数重载<
		bool operator==(const string& s)const;//函数重载==
		bool operator<=(const string& s)const;//函数重载<=
		bool operator>(const string& s)const;//函数重载>
		bool operator>=(const string& s)const;//函数重载>=
		bool operator!=(const string& s)const;//函数重载!=

	private:
		char* _str;        //指向字符数组的指针
		size_t _size;      //字符数组的有效数据的长度
		size_t _capacity;  //字符串数组的容量
		

	public:
		//const static size_t npos = -1; // 虽然可以这样用，但是不建议

		//const static double x;
		// 类内声明
		const static size_t npos;//静态成员变量
	};
	void print_str(const string& s);// const对象的输出 ,打印这个字符串  --- 不能修改

	std::ostream& operator<<(std::ostream& out, const string& s);//流插入
	std::istream& operator>>(std::istream& in , string& s);//流提取
	std::istream& getline(std::istream& in, string& s);//读取一行含有空格的字符串

1.2 前情提要

首先第一点，为了不和库中的string类发生冲突，我们可以包上一个名称为xt_string的命名空间，此时因为作用域的不同，就不会产生冲突了

cpp 复制代码

#pragma once

#include<assert.h>

//为了不和std库中的string类发生冲突，创建我们自己的作用域xt_string
namespace xt_string
{
	class string
	{
	public:
		// ...
	private:
		char* _str;        //指向字符数组的指针
		size_t _size;      //字符数组的有效数据的长度
		size_t _capacity;  //字符串数组的容量
	};
}

接下来呢，就在string.cpp中进行定义，在test.cpp中进行测试即可，其中我们需要包含一下string.h头文件

二、模拟实现string类

2.1 成员函数(Member functions)

2.1.1 构造函数

1、无参构造函数

我们默认_size和_capacity的大小为0，然后给字符数组开一个大小的空间，并且将其初始化为\0

cpp 复制代码

//无参构造函数
//在 xt_string作用域中的string类 的string()函数
xt_string::string::string()
	:_str(new char[1])
	, _size(0)
	, _capacity(0)
{
	_str[0] = '\0';
}

然后，我们在test.cpp中测试一下，因为我们自己实现的string类是包含在了命名空间xt_string中的，所以我们在使用这个类的时候就要使用到域作用限定符::

cpp 复制代码

xt_string::string s1;

cpp 复制代码

#include<string>
using namespace std;

#include"string.h"

void test1()
{
	xt_string::string s1;
	cout << s1 << endl;
}

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

开始运行，但是出现了错误

这个错误是因为我们xt_string::string 类没有定义 operator<<，所以无法用 cout 输出，对于输入输出流运算符，我们后面会讲到，目前，我们先用c_str()函数来代替输出

c_str函数用于获取对象C类型的字符串，实现时直接返回对象的成员变量_str即可

cpp 复制代码

//c_str函数实现
const char* xt_string::string::c_str() const  //内部不进行修改的文件，可以加上const防止权限放大
{
	return _str;
}

然后打印就可以看到正常运行，结果是一个空串

注意：

cpp 复制代码

cout << s1 << endl;  // ❌ 默认不能工作

这里不能工作是因为：s1 是 xt_string::string 类型，cout 不认识这个自定义类型，没有对应的 << 重载

cpp 复制代码

cout << s1.c_str() << endl;  // ✅ 可以工作

这里能工作是因为：c_str() 返回 const char*（C 风格字符串指针），cout 本身就有 operator<<(const char*) 的重载，所以 cout 知道怎么输出 const char*

2、带参构造函数

我们在初始化_size时先计算了字符串str的长度，因为_size取的是到\0为止的有效数据个数(不包含\0)，那么" strlen "刚好可以起到这个功能

然后再_str这一部分，我们为其开辟的空间大小是容量的大小+1(+1的作用是为' \0 '开辟空间)

最后的话还要在把有效的数据拷贝到这快空间中，使用到的是" strcpy "

cpp 复制代码

//带参构造函数
xt_string::string::string(const char* str)
{
	_str = new char[strlen(str) + 1];  // strlen 计算的是字符产的长度 ，不计算'\0' 所以要+1
	_size = strlen(str);
	_capacity = strlen(str);
	strcpy(_str, str);
}

注意：为什么要new一块新空间

cpp 复制代码

#pragma once
#include<iostream>
using namespace std;
namespace yzq
{
    class string
    {
    public:
    string()//无参构造函数
        //初始化列表
        :_str(nullptr)
        ,_size(0)
        ,_capaicty(0)
    {

    }
    string(const char*str)//带参构造函数
        :_str(str),
         _size(strlen(str)),
        _capaicty(strlen(str))
    {

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

    };
    void test()
    {
        string s1;
        string s2("hello world");
    }
}

若写成两个构造函数，一个设置成无参，一个设置成带参，若调用如上的带参构造函数就会报错，将str传给_str，属于权限放大

为了解决这个问题，可以将_str改为const char*类型，但是无法修改_str所指向的内容，调用operator[]函数就会报错

因为后续要考虑扩容等问题，所以最好是new一块空间

而无参的构造函数为了保持析构都用delete[]，所以使用new[]

3、二合一写法

上面两种写法太繁琐了，我们能不能把他们融合在一起呢？

构造函数设置为缺省参数，若不传入参数，则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度（不包括'\0'）

不可以将缺省值设置成nullptr，strlen(str)对于str指针解引用，遇到'\0'终止，解引用NULL会报错

将缺省值设置成一个空字符串，结尾默认为'\0'

常量字符串默认末尾是有 ' \0 '

string.h

cpp 复制代码

//常量字符串默认末尾是有 ' \0 '
string(const char* str = "");//二合一构造函数

cpp 复制代码

//二合一构造函数
xt_string::string::string(const char* str)
{
	_size = strlen(str); //初始时，字符串大小设置为字符串长度
	_capacity = _size; //初始时，字符串容量设置为字符串长度
	_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
	strcpy(_str, str); //将C字符串拷贝到已开好的空间
}

升级版本：strcpy 改成 memcpy

strcpy 在复制时遇到 '\0' 就会立即停止，而 memcpy 则按照指定的字节数进行复制，不会被中间的 '\0' 打断。因此，如果字符串中间包含 '\0'（如 "hello\0world"），使用 strcpy 只能复制到 "hello" 就停止了，而 memcpy(_str, str, _size+1) 会完整复制指定长度的所有字节，包括中间的 '\0' 字符，从而保证数据的完整性

cpp 复制代码

xt_string::string::string(const char* str)
{
	_size = strlen(str); //初始时，字符串大小设置为字符串长度
	_capacity = _size; //初始时，字符串容量设置为字符串长度
	_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
	//strcpy(_str, str); //将C字符串拷贝到已开好的空间
	memcpy(_str, str, _size + 1);
}

补充说明：不过需要注意的是，这段代码中 _size = strlen(str) 本身也会在第一个 '\0' 处停止计算长度，所以如果真要处理含 '\0' 的字符串，还需要额外传入长度参数或使用其他方式获取真实长度。

2.1.2 拷贝构造函数

在拷贝构造函数详解中若未显式定义拷贝构造函数，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数是浅拷贝，或者值拷贝

浅拷贝：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间。其中一个对象的改动会对另一个对象造成影响

深拷贝：深拷贝是指源对象与拷贝对象互相独立。其中任何一个对象的改动不会对另外一个对象造成影响

我们不希望拷贝出来的两个对象之间存在互相影响，因此，我们这里需要用到深拷贝

下面提供两种深拷贝的写法

1、传统写法

思想：先开辟一块足以容纳源对象字符串的空间，然后将源对象的字符串拷贝过去，接着把源对象的其他成员变量也赋值过去即可。因为拷贝对象的_str与源对象的_str指向的并不是同一块空间，所以拷贝出来的对象与源对象是互相独立的

cpp 复制代码

//拷贝构造函数-传统写法
xt_string::string::string(const string& s)
{
	_str = new char[s._capacity + 1];
	//strcpy(_str, s._str);
	memcpy(_str, s._str, s._size + 1);
	_size = s._size;
	_capacity = s._capacity;
}

通过调试，我们观察发现，此时对象s1和对象s2中的数据存放在不同的空间中，此时去修改或者析构都不会受到影响

2、现代写法

首先，我们实现一下swap()函数，他是一个函数模板，可以根据模板参数的自动类型推导来交换不同类型的数据，我们直接调用库里的swap模板函数将对象的各个成员变量进行交换即可。

但我们若是想在这里调用库里的swap模板函数，需要在swap函数之前加上"::"（作用域限定符），告诉编译器优先在全局范围寻找swap函数，否则编译器编译时会认为你调用的是正在实现的swap函数（就近原则）

可以看到在我们自己实现的这个swap(string& s)函数中就去调用了std标准库中的函数然后交换一个string对象中的所有成员变量

cpp 复制代码

//交换函数
void xt_string::string:: swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);

}

重点：若想让编译器优先在全局范围寻找某函数，则需要在该函数前面加上"::"（作用域限定符）

接着我们实现拷贝构造函数

思想：先根据源字符串的C字符串调用构造函数构造一个tmp对象，然后再将tmp对象与拷贝对象的数据交换即可。拷贝对象的_str与源对象的_str指向的也不是同一块空间，是互相独立的

cpp 复制代码

//拷贝构造函数-现代写法
xt_string::string::string(const string& s)
	:_str(nullptr)
	, _size(0)
	,_capacity(0)
{
	string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
	swap(tmp); //交换这两个对象
}

注意：为什么现代写法需要初始化但是传统写法不需要呢？

现代写法的执行流程

cpp 复制代码

string(const string& s)
    :_str(nullptr)      // ① 先初始化为安全值
    , _size(0)
    , _capacity(0)
{
    string tmp(s._str); // ② 创建临时对象，tmp 有正确的数据
    swap(tmp);          // ③ 交换 this 和 tmp 的成员
}                       // ④ 函数结束，tmp 被析构！

如果不初始化的话

cpp 复制代码

string(const string& s)
    // 没有初始化列表，成员是垃圾值！
    // _str = 0xCCCCCCCC（随机野指针）
    // _size = 随机数
    // _capacity = 随机数
{
    string tmp(s._str);  
    swap(tmp);  // 交换后：
                // this->_str = 正确的数据
                // tmp._str = 0xCCCCCCCC（野指针！）
}   
// tmp 析构时调用 delete[] _str
// 对野指针 delete → 程序崩溃！💥

图示对比：

有初始化：

复制代码

交换前:
  this: _str=nullptr, _size=0        (安全值)
  tmp:  _str=有效指针, _size=正确值   (正确数据)

交换后:
  this: _str=有效指针, _size=正确值   ✅ 我们要的结果
  tmp:  _str=nullptr, _size=0        ✅ 析构时 delete nullptr 是安全的

没有初始化：

复制代码

交换前:
  this: _str=野指针, _size=垃圾值     (危险！)
  tmp:  _str=有效指针, _size=正确值

交换后:
  this: _str=有效指针, _size=正确值   ✅ 结果正确
  tmp:  _str=野指针, _size=垃圾值     💥 析构时崩溃！

传统写法为什么不需要

cpp 复制代码

string(const string& s)
{
    _str = new char[s._capacity + 1];  // 直接赋值，覆盖垃圾值
    strcpy(_str, s._str);
    _size = s._size;                    // 直接赋值
    _capacity = s._capacity;            // 直接赋值
}

传统写法直接给每个成员赋值，垃圾值被覆盖了，所有不会有问题

总结：

现代写法用 swap，交换后 tmp 会带着 this 的旧值去析构。如果旧值是垃圾（野指针），析构就会崩溃。所以必须初始化为安全值。

2.1.3 赋值运算符重载

赋值运算符重载也是属于类的默认成员函数，如果我们不自己写的话，类中也会默认生成一个

但是默认生成的话也会造成一个浅拷贝的问题，如下图，我们要执行s1=s3，此时若不去开辟一块新空间的话，那么s1和s3就会指向同一块空间，此时便造成了下面这些问题：

1.在修改其中任何一者时另一者都会发生变化

2.在析构的时候会造成二次析构的

3.原先s1所指向的那块空间没人维护了，就造成了内存泄漏的问题

那么此时我们应该自己去开出一块新的空间，将s3里的内容先拷贝到这块空间中来，然后释放掉s1所指向这块空间中的内容，然后再让s1指向这块新的空间

这个时候，也就达成了我们所要的【深拷贝】，不会让二者去共同维护同一块空间

最后不要忘记去修改一下s1的【_size】和【_capacity】，因为大小和容量都发生了改变

1、传统写法

cpp 复制代码

//赋值运算符重载-传统写法
xt_string::string& xt_string::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;
}

2、现代写法

思想：在这个赋值重载的函数内部调用了拷贝构造去获取到一个临时对象tmp，然后再通过swap()函数去交换当前对象和tmp的指向，此时s1就刚好获取到了赋值之后的内容，而tmp呢则是一个临时对象，出了当前函数的作用域后自动销毁，那么原本s1所维护的这块空间刚好就会销毁了，也不会造成内存泄漏的问题

透过上面这个图解应该对新的这种拷贝构造有了一定的理解：反正tmp对象出了作用域也要销毁的，你手上呢刚好有我想要的东西，那我们换一下吧，此时我得到了我想要的东西，你呢拿到了我的东西，这块地址中的内容刚好就是要销毁的，那tmp在出了作用域后顺带就销毁了，这也就起到了【一石二鸟】的效果

cpp 复制代码

//赋值运算符重载-现代写法
xt_string::string& xt_string::string::operator=(const string& s)
{
	if (this != &s)//防止自己给自己赋值
	{
		string tmp(s);//用s拷贝构造出对象tmp
		swap(tmp);//交换这两个对象
	}
	return *this;//返回左值（支持连续赋值）
}

**代码升级：传值传参**

cpp 复制代码

//赋值运算符重载-现代写法
xt_string::string& xt_string::string::operator=(string tmp)
{
	swap(tmp);//交换这两个对象
	return *this;//返回左值（支持连续赋值）
}

先回顾：两种传参方式的区别

cpp 复制代码

void func1(string s);      // 传值：s 是实参的【副本】
void func2(string& s);     // 传引用：s 是实参的【别名】
void func3(const string& s); // 传常引用：s 是实参的【只读别名】

传值传参会发生什么

当我们调用一个传值的函数时，编译器会自动调用拷贝构造函数来创建副本：

cpp 复制代码

void func(string s)  // 传值
{
    // s 是一个全新的对象，是实参的拷贝
}

int main()
{
    string s1("hello");
    func(s1);  // 这一步会调用拷贝构造函数，创建 s 作为 s1 的副本
}

执行流程：

复制代码

调用 func(s1)
    ↓
编译器自动执行：string s(s1);  ← 调用拷贝构造函数！
    ↓
进入函数体，s 是 s1 的独立副本
    ↓
函数结束，s 析构

应用到赋值运算符

对比两种写法：

cpp 复制代码

// 写法1：传引用（传统）
string& operator=(const string& s)
{
    if (this != &s)
    {
        string tmp(s);  // 【手动】调用拷贝构造
        swap(tmp);
    }
    return *this;
}

// 写法2：传值（现代）
string& operator=(string tmp)  // 【自动】调用拷贝构造！
{
    swap(tmp);
    return *this;
}

传值写法的详细执行过程

假设执行 s1 = s2;

复制代码

步骤1：调用 s1.operator=(s2)
        ↓
步骤2：因为参数是 string tmp（传值），
       编译器自动执行：string tmp(s2);  ← 拷贝构造！
       此时 tmp 是 s2 的深拷贝副本
        ↓
步骤3：进入函数体，执行 swap(tmp);
       交换 this(s1) 和 tmp 的内部指针
        ↓
步骤4：函数结束，tmp 析构
       tmp 现在持有的是 s1 的【旧数据】
       析构函数自动释放这些旧内存！

图解：

复制代码

调用前：
s1._str  ──►  "old data"     (s1的旧数据)
s2._str  ──►  "new data"     (s2的数据)

步骤2 - 拷贝构造 tmp：
s1._str  ──►  "old data"
s2._str  ──►  "new data"
tmp._str ──►  "new data"     (tmp是s2的深拷贝)

步骤3 - swap 交换：
s1._str  ──►  "new data"     (s1指向新数据！)
tmp._str ──►  "old data"     (tmp接管了旧数据)

步骤4 - tmp 析构：
s1._str  ──►  "new data"     (s1保留)
tmp._str ──►  "old data"  💥 被delete释放！

为什么不需要判断自赋值

传引用写法必须判断 if (this != &s)，否则自赋值会出问题

但传值写法天然安全：

cpp 复制代码

s1 = s1;  // 自赋值

// 执行过程：
string tmp(s1);  // tmp 是 s1 的独立副本，有自己的内存
swap(tmp);       // 交换后，s1 得到 tmp 的副本数据
                 // tmp 得到 s1 的原数据
// tmp 析构，释放的是【原来 s1 的数据】
// 但 s1 现在指向的是【tmp 的副本数据】，没有被释放！

因为 tmp 是独立副本，所以交换后各自持有独立的内存，不会冲突

传值的妙处

传值传参的好处在于：当你把参数声明为 string tmp 而不是 const string& s 时，编译器会在调用函数的那一刻自动帮你调用拷贝构造函数 创建一个独立的副本，这样你就不用在函数体内手动写 string tmp(s) 了；同时，这个副本 tmp 是函数的局部变量 ，当函数结束时会自动析构 ，而此时 tmp 通过 swap 已经接管了原对象的旧数据，所以旧内存也被自动释放了------整个过程中，"拷贝"和"清理"这两件最容易出错的事都交给了编译器自动完成，你只需要写一行 swap(tmp) 就够了，代码既简洁又安全，还天然支持自赋值。

2.1.4 析构函数

cpp 复制代码

//析构函数
xt_string::string::~string()
{
	delete[] _str;//释放_str指向的空间
	_str = nullptr;//及时置空，防止非法访问
	_size = _capacity = 0;
}

2.2 元素访问(Element access)

我们把基本的成员函数讲解完了，string对象也被构造出来了，接下来访问一下对象里面的内容吧

STL讲解(二)—string类的模拟实现

文章目录

一、前言

1.1 string类各函数接口总览

1.2 前情提要

二、模拟实现string类

2.1 成员函数(Member functions)

2.1.1 构造函数

2.1.2 拷贝构造函数

2.1.3 赋值运算符重载

2.1.4 析构函数

2.2 元素访问(Element access)

2.2.1 operator[ ]