【C++初阶】第八站:string类的模拟实现

这篇具有很好参考价值的文章主要介绍了【C++初阶】第八站:string类的模拟实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

目录

string类的模拟实现

经典的string类问题

浅拷贝

深拷贝

写时拷贝(了解)

构造函数

string的全缺省的构造函数:

string的拷贝构造函数

传统写法

现代写法

string的赋值重载函数

传统写法

现代写法

string的无参构造函数:

遍历函数

operator[ ]

迭代器

迭代器的底层实现begin和end:

范围for的使用

修改字符串相关函数:

reserve 

push_back

append

operator+=

insert(字符的版本)

insert(字符串常量)

erase

resize

find(查找单个字符)

find(查找子串)

substr

比较运算符的重载:

流插入cout

流提取cin

优化写法

clear


前言:

🎯个人博客:Dream_Chaser

🎈博客专栏:C++

📚本篇内容:string类通用函数的模拟实现

string类的模拟实现

经典的string类问题

上面已经对string类进行了简单的介绍,大家只要能够正常使用即可。在面试中,面试官总喜欢让学生自己来模拟实现string类,最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题?

浅拷贝

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

说明:上述String类没有显式定义其拷贝构造函数与赋值运算符重载,此时编译器会合成默认的,当用s1构 造s2时,编译器会调用默认的拷贝构造。最终导致的问题是,s1、s2共用同一块内存空间,在释放时同一块 空间被释放多次而引起程序崩溃,这种拷贝方式,称为浅拷贝。

浅拷贝

浅拷贝:也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共 享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为 还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。

深拷贝

如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

写时拷贝(了解)

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

写时拷贝就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成1,每增加一个对象使用该资源,就给计数增加1,当某个对象被销毁时,先给该计数减1,然后再检查是否需要释放资源,如果计数为1,说明该对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。

构造函数

string的全缺省的构造函数:

我们对string成员函数进行模拟实现的时候,首先要定义一个自定义的命名空间,避免与库里面的冲突:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

让我们来看看错误的案例:

①注意常量字符串的用法,权限不能放大:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

②尝试给_str声明加上const,这样就会导致初始化的时候出现随机值:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

③需要注意的是"string.h"要定义在std的下方:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

那么带参的构造可以怎么写呢?初始化列表的顺序应该对应着成员变量声明的顺序

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

string带参的构造是否可以再优化一下呢?

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

注意new的时候的+1是为了给'\0'预留的空间:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

代码实现:

此构造函数接受一个可选参数(默认为空字符串),用于初始化一个字符串对象,根据传入的C风格字符串(const char* 类型)计算其长度,并据此分配内存空间,最后,将传入的字符串内容复制到新分配的内存区域,以便在C++字符串类中进行管理。

//构造函数,用于初始化一个字符串类对象
string(const char* str = "")
			:_size(strlen(str))// 初始化_size成员变量,存储传入C风格字符串(char数组)str的长度
			, _capacity(_size)// 初始化_capacity成员变量,初始容量与传入字符串长度相同
		{
			_str = new char[_capacity + 1];// 动态分配内存,为字符串对象分配一个新的字符数组
			strcpy(_str, str); // 使用strcpy将传入的字符串str复制到新分配的字符数组中
		}

string的拷贝构造函数

传统写法

//传统写法 -- 拷贝构造
//s2(s1)
string(const string& s)
{
	_str = new char[s._capacity + 1];//仅仅开空间
	strcpy(_str, s._str);//
	_size = s._size;
	_capacity = s._capacity;
}

现代写法

// 定义交换函数,将当前字符串对象与输入参数s的内部数据(字符数组、长度及容量)进行交换
void swap(string& s) {
    // 使用STL中的std::swap交换三个关键成员变量
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_size, s._capacity);
}

// 构造函数,复制输入参数s的字符串内容
// 使用临时字符串对象tmp存储s的内容,然后通过调用swap函数交换数据
string(const string& s) :
    _str(nullptr),
    _size(0),
    _capacity(0)
{
    string tmp(s._str); // 创建临时字符串tmp,拷贝s的内容
    swap(tmp); // 交换当前对象与tmp的数据,实现深拷贝
}

string的赋值重载函数

传统写法

//传统写法--赋值重载
// 使得可以使用 "s2 = s3" 的形式,将 s3 字符串对象的值赋给 s2
string& operator=(const string& s)
{
    // 检查是否为自我赋值,即检查是否同一个对象
    if (this != &s)
    {
        // 创建一个临时字符数组 tmp,大小为 s 的容量加一(包含结束符 '\0')
        char* tmp = new char[s._capacity + 1];

        // 使用 strcpy 函数将 s 的内部字符串复制到临时数组 tmp 中
        strcpy(tmp, s._str);

        // 删除当前对象已有的内部字符串数组
        delete[] _str;

        // 将临时数组 tmp 的地址赋给当前对象的内部字符串指针 _str
        _str = tmp;

        // 将源字符串对象 s 的大小赋给当前对象的大小属性 _size
        _size = s._size;

        // 同样将源字符串对象 s 的容量赋给当前对象的容量属性 _capacity
        _capacity = s._capacity;
    }

    // 返回当前对象的引用,以支持连续赋值如 "s1 = s2 = s3"
    return *this;
}

现代写法

// 重载赋值运算符,实现字符串对象之间的深拷贝赋值操作
string& operator=(const string& s)
{
    // 检查是否自我赋值(即源对象与目标对象相同),避免不必要的资源释放与重新分配
    if (this != &s)
    {
        // 创建临时字符串对象tmp,并使用s的内容初始化
        string tmp(s);

        // 调用自定义的swap函数,将当前对象的数据与临时对象tmp的数据进行交换
        // 这样可以确保原对象的资源被正确释放,并且新内容被赋值给当前对象
        swap(tmp);
        
        // 注:这里原本可能是 "this->swap(tmp);",但因为 "swap" 是成员函数,
        // 在成员函数内部可以直接调用,无需 "this->"。
    }

    // 返回当前对象的引用,以便支持连续赋值操作
    return *this;
}

现代写法优化

//现代写法优化
string& operator=(string tmp)
{
	swap(tmp);
	return *this;
}

string的无参构造函数:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

经过尝试之后,可以发现以下问题:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

无参的构造应该这样写:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

代码实现: 建议只写一个全缺省的构造函数即可,因为默认构造函数只能存在一个。

String()
	:_str(new char[1]{'\0'})//数组的初始化方式
	,_size(0)
	,_capacity(0)
	{}

遍历函数

c_str函数

简要说明

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

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

operator[ ]

这里要演示的话就得遍历这个字符串,需要重载一下operator[ ]:

	void test_string1()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		string s2;
		cout << s2.c_str() << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i] << " ";
		}
		cout << endl;
}

需要区分只能读和可读可写的版本:

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

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

代码执行: 

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

既然说到遍历数组的话,那就少不了迭代器。

迭代器

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

迭代器声明: 

//声明
typedef char* iterator;//可读可写
typedef const char* const_iterator;//只可读

迭代器的底层实现begin和end:

begin:函数的作用就是返回字符串中第一个字符的地址

//实现:
iterator begin()
{
	return _str;
}

const_iterator begin()const
{
	return _str;
}

end函数的作用就是返回字符串中最后一个字符的后一个字符的地址(即’\0’的地址)

//实现:
iterator end()
{
	return _str + _size;//指向'\0'
}
const_iterator end()const
{
	return _str + _size;//指向'\0'
}

迭代器外层调用:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

范围for的使用

同时为了方便理解,把范围for的实现列举出来:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

当咱们将begin改为Begin时,发现会出错,还有一个点:范围for的本质是迭代器

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

迭代器与范围for的应用: 

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

怎么能够让改变后的字符串,不再变回原来的字符串呢?使用引用即可:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

实例代码:

void test_string1()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		string s2;
		cout << s2.c_str() << endl;

	/*	for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i] << " ";
		}
		cout << endl;*/

		string::iterator it = s1.begin();
		while (it != s1.end())
		{
			(*it)++;
			cout << *it << " ";
			++it;
		}
		cout << endl;
		for (auto& ch : s1)//使用引用
		{
			ch++;//让字符串里每个字符的ascll码值+1
			cout << ch << " ";
		}
		cout << endl;
		cout << s1.c_str() << endl;
	}

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

修改字符串相关函数:

reserve 

        其主要作用是预先为容器分配足够的未使用容量,以应对未来可能的元素添加,而不立即改变容器的大小(元素数量)。使用 reserve() 可以有策略地控制容器的内存分配,提高连续添加元素时的效率

void reserve(size_t n)
{
	// 检查请求的容量n是否大于当前内部缓冲区的实际容量(_capacity)
	if (n > _capacity)
	{
	 // 如果是,则需要重新分配更大的内存空间。新分配的内存大小为n+1,+1用于存储结尾的空字符'\0
	    char* tmp  = new char[n + 1];//+1存“\0'
	    strcpy(tmp,_str);//将当前字符串内容(包括结尾的'\0')复制到新分配的tmp缓冲区中
	    delete[] _str;// 释放原有的内部缓冲区(_str),以避免内存泄漏
	    _str = tmp;// 更新内部缓冲区指针,指向新分配的tmp缓冲区
	    _capacity = n;// 更新内部记录的缓冲区容量为请求的值n
	 }
}

push_back

  push_back() 是序列容器(如 std::vectorstd::liststd::deque 等)的成员函数,用于在容器末尾添加新元素。它自动处理内存管理,确保新元素顺利加入,且保持原有元素顺序不变。对于动态扩容容器(如 std::vector),在必要时会自动增大容量。 

尝试:可以写成这样吗?不行,当_capacity = 0 时,空间还没分配到,此时如果访问就属于越界访问

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

代码实现:

void push_back(char ch)
{
	// 检查当前内部字符串长度(_size)是否已达到内部缓冲区容量(_capacity)
	if (_size == _capacity)
	{
	    // 若已满,调用reserve函数预分配新的内存,扩大容量。
		// 首次扩容时容量设为4,后续扩容按当前容量翻倍。
			reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
		// 将待添加字符ch 存储在 内部字符串缓冲区的当前长度索引处(_size)
	         _str[_size] = ch;
			 ++_size;// 更新内部字符串长度(_size),增1以包含新添加的字符
			 _str[_size] = '\0';// 在新添加字符之后添加空字符('\0'),确保字符串正确终止
}

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

append

对于std::string:append()用于在字符串末尾追加其他字符串、字符数组或单个字符,可以指定追加的起始位置和长度。

void append(const char* str)
{
	int len = strlen(str);// 获取输入字符串str长度
	// 检查是否需扩大内部缓冲区容量以容纳追加的str
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
		//这个地方要是忘记 +_size,从头到尾覆盖新字符串
		strcpy(_str+_size,str);// 将str追加到内部字符串缓冲区末尾
		_size += len;// 更新内部字符串长度
}

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

push_backappend 的区别在于一个追加字符,另一个追加字符串

示例:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

operator+=

+=运算符的重载:分别复用了 push_back  和  append, 实现字符串与字符,字符串与字符串之间能够直接使用+=运算符进行尾插。

字符串追加字符:

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

字符串追加字符串:

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

示例运行:
【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

void test_string2 ()
{
	string s1("hello world");
	s1 += '#';
	s1 += "css";
	cout << s1.c_str() << endl;

	string s2;
	s2 += '#';
	s2 += "csgo";
	cout << s2.c_str() << endl;
}

insert(字符的版本)

尝试写一下insert:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

测试一下代码的可行性:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言 可以发现头插会出错:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

头插:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

那就换成有符号,此时pos为0,end为-1,此时end<pos,但是依然进入了循环,明显的不对吧,这里是发生了类型转换,end变成无符号整型了。

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

怎么解决呢:以下两种写法都是正确的:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

此时函数的功能:

在动态字符数组 _str 的指定位置 pos 插入一个字符 ch。首先,它验证插入位置的有效性(必须小于等于当前数组大小_size)。

若当前数组容量已满,函数会自动扩容,初始容量为4或者当前容量的两倍。

然后,函数通过循环将 pos位置之后的所有元素向右移动一位,为新字符腾出空间。

最后,函数在指定位置pos插入字符ch,并将数组大小_size加一,表示数组元素数量增加。 

//上图的版本二
void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
    _str[pos] = ch;
	_size++;
}

insert(字符串常量)

该函数的作用:

        用于在动态字符数组(或类似字符串结构)的指定位置pos插入一个C风格字符串str。首先,它通过断言确保插入位置的有效性。

        接着计算待插入字符串的长度,并检查现有容量是否足够容纳插入后的完整字符串,不足则调用reserve进行扩容。

        然后,函数将插入位置之后的所有字符向右移动适当距离,为新字符串腾出空间。最后,使用strncpy函数将待插入字符串复制到目标位置,并更新整个字符串的大小,反映出新增字符的影响。

首先要注意:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

所以需要强转:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

//   pos:插入位置,从0开始计数
//   str:要插入的C风格字符串

void insert(size_t pos, const char* str)
{
    // 断言检查,确保插入位置pos不大于当前字符串的大小
    assert(pos <= _size);

    // 获取要插入字符串str的长度,即需要移动的字符数量
    size_t len = strlen(str);

    // 检查插入后字符串总长度是否超过当前容量,如果超过则进行扩容
    if (_size + len > _capacity)
    {
        reserve(_size + len);  // 调用reserve函数来增加内部缓冲区的容量
    }

    // 数据挪动部分:
    // 将插入位置pos之后的所有字符向右移动len个位置
    int end = static_cast<int>(_size);  // 使用int类型方便进行减操作,注意这里假设_size不会超出int表示范围
    while (end >= static_cast<int>(pos))
    {
        _str[end + len] = _str[end];  // 将原字符串中下标为end的字符移动到end + len的位置
        --end;                        // 移动指针至下一个待移动的字符
    }

    // 在指定位置pos处插入字符串str
    strncpy(_str + pos, str, len);  // 使用 strncpy 函数将str复制到目标字符串相应位置

    // 更新字符串的大小
    _size += len;  // 插入操作完成后,字符串的新长度应增加len
}

erase

        作用是从动态字符数组(或类字符串结构)的特定位置pos开始删除指定长度len的子串。

        首先,它通过断言确保删除起始位置的有效性(小于当前字符串长度_size)。根据传入的参数,函数会判断是否需要删除从pos到结尾的所有字符,

        如果是,则将pos位置之后的字符置为结束符\0,并将字符串大小更新为pos;否则,将从pos+len开始到结尾的字符依次向前移动len个位置以覆盖待删除区域,并相应减少字符串大小_size

        简而言之,该函数实现了对字符串的指定范围擦除操作。

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

// 函数:删除指定位置起始的子串,若未指定长度,默认删除到字符串末尾
void erase(size_t pos, size_t len = npos)
{
    // 检查删除起始位置是否合法(必须在当前字符串内)
    assert(pos < _size);

    // 如果未指定长度或指定长度使删除范围超出字符串末尾,则删除从pos到字符串末尾的部分
    if (len == npos || pos+len >= _size)
    {
        // 截断字符串,将pos位置置空字符,字符串长度变为pos
        _str[pos] = '\0';
        _size = pos;
    }
    // 否则,按指定长度删除子串
    else
    {
        // 计算删除范围结束后的新起始位置
        size_t begin = pos + len;

        // 将删除范围后的字符逐个向前移动len位,覆盖待删除部分
        while (start <= _size)
        {
            _str[begin - len] = _str[begin];
            ++begin;
        }

        // 更新字符串长度,减少len
        _size -= len;
    }
}

resize

作用: 改变动态字符数组(或类字符串结构)的大小,并可选地用指定字符ch填充新添加的空间。

        若新指定长度n小于等于当前长度,函数将截断字符串,使其长度变为n

        若新长度大于当前长度且可能超过当前容量时,函数先调用reserve进行扩容,然后使用给定字符ch填充新增的字符位置,直到字符串长度达到指定的n,并在字符串末尾添加结束符\0,以确保字符串的完整性和正确性。

        总之,此函数灵活地调整了字符串的长度,并保持其内容的有效性。

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

void resize(size_t n, char ch = '\0')
{
    // 当新长度n小于等于当前字符串长度时,执行删除操作
    if (n <= _size)
    {
        // 将第n个字符设置为空字符,相当于截断字符串,并更新字符串的实际长度为n
        _str[n] = '\0';
        _size = n;
    }
    // 当新长度n大于当前字符串长度但小于等于当前容量时,或新长度n大于当前容量时
    else
    {
        // 先调用reserve函数确保容量足够容纳新长度的字符串
        reserve(n);

        // 循环填充字符,直至字符串长度达到n
        while (_size < n)
        {
            _str[_size] = ch; // 使用指定字符ch填充
            ++_size;
        }

        // 最后,在新字符串末尾添加结束符'\0'
        _str[_size] = '\0';
    }
}

find(查找单个字符)

// 定义一个成员方法,用于在当前字符串对象中查找指定字符 ch 的首次出现位置
//ch --  要查找的字符
// 查找的起始位置,默认从字符串开头(索引0)开始

size_t find(char ch, size_t pos = 0)
{
    // 使用一个循环遍历从 pos 位置开始到字符串结尾的所有字符
    for (size_t i = pos; i < _size; i++) 
    {
        // 检查当前遍历到的字符是否与要查找的字符 ch 相同
        if (_str[i] == ch) 
        {
            // 如果相同,则返回该字符在字符串中的索引位置
            return i;
        }
    }

    // 若遍历完整个指定区间后仍未找到字符 ch,则返回 npos
    // npos 是一个特殊的值,通常表示“未找到”或“无效位置”
    return npos;
}

find(查找子串)

size_t find(const char* sub, size_t pos = 0)
{
    // 使用C语言库函数strstr查找子串sub在当前字符串(从pos开始的部分)中首次出现的位置
    const char* p = strstr(_str + pos, sub);

    // 如果找到了子串sub,则返回子串首字符在当前字符串中的相对索引(即下标)
    if (p)
    {
        return p - _str;
    }
    // 若找不到子串,则返回特殊值npos,表示子串不在当前字符串中
    else
    {
        return npos;
    }
}

substr

// 定义一个方法,用于从原始字符串中提取子串
string substr(size_t pos, size_t len /* 默认为最大长度 */) {
    // 创建一个新字符串 s 来保存子串
    string s;

    // 计算子串的结束位置(默认取到原始字符串结尾)
    size_t end = pos + len;
    if (len == npos || pos + len >= _size) {
        // 若指定长度超过原始字符串剩余长度,则取剩余全部字符
        len = _size - pos;
        end = _size;
    }

    // 为新字符串预分配足够内存以存放子串
    s.reserve(len);

    // 循环遍历原始字符串,从 pos 位置开始,复制到新字符串 s 中,直到结束位置 end
    for (size_t i = pos; i < end; i++) {
        s += _str[i];
    }

    // 返回包含子串的新字符串 s
    return s;
}

比较运算符的重载:

bool operator<(const string& s)const
{
	return strcmp(_str,s._str);
}
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 || *this == s);
}
//>=
bool operator>=(const string& s)const
{
	return !(*this < s);
}

bool operator!=(const string& s)const
{
	return !(*this == s);
}

流插入cout

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

这里的范围for可以访问吗?不可以:这里要用const迭代器,因为是一个被const修饰的对象,const迭代器指针本身是可以++(修改)的,指针指向的内容不可以被修改:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言所以要这样做:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

代码:

class string
{
public:
	typedef char* iterator;
	typedef const char* const_iterator;//const迭代器
}

ostream& operator<<(ostream& out, const string& s)
{
/*	for (size_t i = 0; i < s.size(); i++)
{
	   out << s[i];
}*/
    for (auto ch : s)
	   out << ch;
		
	return out;
}

流提取cin

需要注意的地方:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

那么应该这样去写:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

代码: 

istream& operator>>(istream& in, string& s)
{
	s.clear();//清理原来的字符数据,不然就变成尾插了
	char ch;
	//in >> ch;//拿不到 空格 或者 换行
	ch = in.get();//一个字符一个字符的拿
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		//in >> ch;
		ch = in.get();
	}
		return in;
}

优化写法

// 重载输入流提取运算符 >>,使得可以从输入流(如cin)中读取一串连续的非空格和非换行符字符到string对象s中
istream& operator>>(istream& in, string& s)
{
// 清空目标string对象s,准备接收新的输入
s.clear();

// 定义一个固定大小的缓冲区buff,用于暂存从输入流中读取的字符
    char buff[129];
    size_t i = 0; // 初始化缓冲区索引为0

// 从输入流in中获取第一个字符
    char ch;
    ch = in.get();

// 当读取到的字符不是空格也不是换行符时,继续循环
while (ch != ' ' && ch != '\n')
{
    // 将字符放入缓冲区
    buff[i++] = ch;

    // 如果缓冲区已满(达到128个字符)
    if (i == 128)
    {
        // 在缓冲区末尾添加结束符'\0',将其视为一个C风格字符串添加到目标string对象s中
        buff[i] = '\0';
        s += buff; // 更新s的内容

        // 重置缓冲区索引为0,以便继续填充下一个子字符串
        i = 0;
    }

    // 继续从输入流中获取下一个字符
    ch = in.get();
}

// 若缓冲区中仍有剩余字符(循环结束后)
if (i != 0)
{
    // 添加结束符'\0',将剩余的子字符串添加到目标string对象s中
    buff[i] = '\0';
    s += buff;
}

// 返回输入流in的引用,以支持链式输入操作
    return in;
}

clear

不清理之前的数据就变成尾插了:

【C++初阶】第八站:string类的模拟实现,C++,c++,开发语言,编程语言,函数的模拟实现,C语言

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

本篇结束。

🔧本文修改次数:0

🧭更新时间:2024年4 月 24 日 文章来源地址https://www.toymoban.com/news/detail-860934.html

到了这里,关于【C++初阶】第八站:string类的模拟实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】string类的模拟实现

    前言:在上一篇中我们讲到了string类的使用方法,今天我们将进一步的去学习string类,去底层看看它顺带模拟实现部分的内容。 💖 博主CSDN主页:卫卫卫的个人主页 💞 👉 专栏分类:高质量C++学习 👈 💯代码仓库:卫卫周大胖的学习日记💫 💪关注博主和博主一起学习!一起努

    2024年03月21日
    浏览(43)
  • 【C++】String类的模拟实现。

    🎉博客主页:小智_x0___0x_ 🎉欢迎关注:👍点赞🙌收藏✍️留言 🎉系列专栏:C++初阶 🎉代码仓库:小智的代码仓库 string类中需要三个成员变量分别记录元素个数、容量和内容。还需要一个 size_t 类型npos-1表示整型的最大值。 这段代码是 string 类的构造函数。构造函数是在

    2024年02月13日
    浏览(40)
  • C++ 之 string类的模拟实现

    这学习我有三不学 昨天不学,因为昨天是个过去 明天不学,因为明天还是个未知数 今天不学,因为我们要活在当下,我就是玩嘿嘿~ –❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀-正文开始-❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–

    2024年04月27日
    浏览(31)
  • 【C++】——string类的介绍及模拟实现

    C语言中,字符串是以’\\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。所以我们今天来学习C++标准库中的string类。

    2024年02月07日
    浏览(54)
  • 【c++】string类的使用及模拟实现

    我们先了解一下什么是OOP思想 OOP思想,即面向对象编程(Object-Oriented Programming)的核心思想,主要包括“抽象”、“封装”、“继承”和“多态”四个方面。 抽象:抽象是忽略一个主题中与当前目标无关的那些方面,以便充分地注意与当前目标有关的方面。抽象并不打算了

    2024年04月11日
    浏览(34)
  • STL中的string类的模拟实现【C++】

    构造函数设置为缺省参数,若不传入参数,则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度(不包括’\\0’) 在模拟实现拷贝构造函数前,我们应该首先了解深浅拷贝: 浅拷贝:拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一

    2024年02月15日
    浏览(39)
  • 【C++初阶】模拟实现string的常见操作

    👦个人主页:@Weraphael ✍🏻作者简介:目前学习C++和算法 ✈️专栏:C++航路 🐋 希望大家多多支持,咱一起进步!😁 如果文章对你有帮助的话 欢迎 评论💬 点赞👍🏻 收藏 📂 加关注✨ 为了方便管理代码,分两个文件来写: Test.cpp - 测试代码逻辑 string.h - 模拟实现 strin

    2024年02月12日
    浏览(50)
  • 【C++】深度剖析string类的底层结构及其模拟实现

    在上两篇中,我们已经学习了string类的一个使用,并且做了一些相关的OJ练习,相信大家现在对于string的使用已经没什么问题了。 那我们这篇文章呢,就来带大家对string进行一个模拟实现,这篇文章过后,有些地方大家或许就可以理解的更深刻一点。 那通过之前文章的学习我

    2023年04月17日
    浏览(103)
  • 【C++练级之路】【Lv.6】【STL】string类的模拟实现

    欢迎各位小伙伴关注我的专栏,和我一起系统学习C语言,共同探讨和进步哦! 学习专栏 : 《进击的C++》 关于 STL容器 的学习,我会采用 模拟实现 的方式,以此来更加清楚地了解其 底层原理和整体架构 。而string类更是有100多个接口函数,所以模拟实现的时候只会调重点和

    2024年01月18日
    浏览(46)
  • [C++] string类的介绍与构造的模拟实现,进来看吧,里面有空调

    C语言中,字符串是以’\\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合面向对象的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 因此C++中,为了让我们更简单、方便

    2024年02月12日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包