c++的学习之路：10、string（2）

本章主要说一下模拟实现string类的部分功能，文章末附上所有代码。

目录

一、构造函数与析构函数

二、拷贝构造

三、c_str

四、【】和迭代器的遍历与访问

五、size

六、判断

七、reserve

八、push_back

九、resize 

十、append

十一、+=

十二、insert

十三、erase

十四、全部代码

一、构造函数与析构函数

首先构造函数就是利用之前所学的知识进行构造，利用初始化列表进行计算一下所需要初始化的对象的大小，也就是字符串的大小，如下方代码所示size显示利用strlen计算一下所需要的大小，然后容量这里是利用了三目运算符判断一下，如果字符串为空就多创建几个，如果字符串有大小就创建字符串大小的容量，然后利用new进行创建，这里需要把‘\0’算上，所以就是容量+1，然后在利用strcpy拷贝过去，析构函数就是利用delete[ ] 去释放所申请的空间，并且置为空，再把size和capacity置为0，这个就是析构函数的写法，那么实践一下是否成功，测试结果如下图，可以从图一看到构造函数很成功，图二也可以看出析构函数也很成功。

class String
{
public:
    String(const char* str = "")
        :_size(strlen(str))
    {
        _capacity = _size == 0 ? 4 : _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }
    }
private:
    char* _str;
    size_t_size;
    size_t_capacity;
};

void Test1()
{
    String s1;
    String s2("Hello word!");
}

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

那么如果利用s2这个已有的字符串创建呢？可以吗 ？

如下图一可以看出在第一次析构函数调用成功后s3是正常析构，可是s2的字符串就变成了乱码，也就是这块地址被释放了，如图二s2和s3所指向了同一个地址，这个就是之前讲过的构成了拷贝构造，所以编译器自动生成了一个拷贝构造，但是这个只是一个值拷贝也就是浅拷贝，所以就会出现指同一个空间的情况，所以这里的解决方法，就是如下方代码所是这样利用引用进行构造这个对象，可以从下方图三看出地址不是一样，这样就不会出现图一图二的错误了。

 

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

二、拷贝构造

在赋值的时候，编译器所自动生成的拷贝就是浅拷贝，所以这里需要自己写一个深拷贝，要不然用s2给s1赋值都赋值不了，实现代码如下，测试如图发现是可以进行赋值的，这里是先判断这两个地址是否相同，不同的话进行拷贝，首先是创建了一个行的地址，里面存放的就是需要拷贝的字符串，然后再把旧的字符串释放掉，在指向这个地址，size和capapcity都赋值成等于号的右值。

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

三、c_str

这个在官方的文档中的意思就是返回c形式的字符串，因为使用流插入的话，遇到\0并不会停止，会全部打印结束，所以这里就是需要这种函数来应付这种场合，测试图和代码如下，这里不需要改动字符串，只是访问所以利用const修饰了一下，下文这中只读的都会利用const去修饰。

 const char* c_str()
    {
        return _str;
    }

四、【】和迭代器的遍历与访问

这个就是相当于运算符重载，利用【】去访问与遍历，像数组那样访问与遍历，上篇文章说了有三种访问与遍历的方式，【】访问迭代器遍历和范围for的遍历，[]的测试结果和代码如下。

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

迭代器这里就下了两种的，一种是可读可写的，另一种就是只读的，也就是const_iterator这种类型的，普通的测试代码和结果如下。

iterator begin()
    {
        return _str;
    }
    iterator end()
    {
        return _str + _size;
    } 

String::iterator it = s2.begin();
    while (it != s2.end())
    {
        cout << *it;
        it++;
        *it = 'a';
    }
    cout << endl;

如果把s3转成const类型进行利用迭代器就会不能给改，错误如下这时就可以利用const_iterator这个了实现代码如下。

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

for这个语法糖可以直接访问，因为这个底层就是迭代器，代码如下。

for (auto it3 : s2)
    {
        cout << it3;
    }
    cout << endl; 

五、size

这个就是获取对象的size数据也就是大小，代码和测试结果如下，这里就可以利用之前获取的size数据直接返回。

size_t size() const
    {
        return _size;
    } 

六、判断

这个就是说下几个判断，判断的是字符串的ASCLL码值，直接利用strcmp进行直接复用判断使用，代码和测试结果如下。

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 || s == *this;
    }

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

七、reserve

这个函数的用法就是创建一个空间，这个空间的大小可以进行指定，也就是相当于扩容，代码与测试结果如下，s1也成功扩容成功，他先是创建一个足够大的地址空间，然后释放掉旧的在把临时拷贝的地址给原来的指针就OK了。

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

八、push_back

这个我看到的时间就想起了之前学习数据结构的时候，尾插！这个尾插写的时候，就是判断当size+1大于capacity的时候就进行扩容，我这里是扩容的2倍，然后在进行拷贝数据，在把size++然后在把字符串尾写上\0，如下图可以看出尾插是正常的，代码如下。

void push_back(char ch)
    {
        if (_size + 1 > _capacity)
        {
            reserve(_capacity * 2);
        }
        _str[_size] = ch;
        ++_size;
        _str[_size] = '\0';
    }

九、resize 

这个在cplusplus网站中的解释如下图，可以看出他有两个参数，第一个是长度，第二个是字符，就是进行扩容，然后如果新的地址比旧的长的时候，就把后面的字符尾插在字符后面，实现代码如下，下方图二就是测试的结果。

 

void resize(size_t n,char c)
    {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        while (n-_size-1)
        {
            tmp[_size] = c;
            _size++;
        }
        delete[] _str;
        _str = tmp;
        _capacity = n;
        ++_size;
        _str[_size] = '\0';
        
    } 

十、append

这个就是和push_back的用法差不多，但是是追加字符串，这个用法就是直接计算字符串长度，然后开辟空间，在把字符串拷贝过去，如下图所示。

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

十一、+=

这里是直接复用了push_back和append，代码和测试如下。

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

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

 

十二、insert

这个insert就是在pos位置插入字符，如下方代码就可以看出，有_size可以找出字符串的尾，然后--挪动数据，找到pos的位置然后插入字符，再把size++，对了不能忘了先判断扩容，测试代码如下。

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

十三、erase

把pos位置数据删除，这里也就是直接找到pos位置然后直接覆盖，在--size就可以了，测试代码和结果如下。

void erase(size_t pos)
    {
        assert(pos <= _size);

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

 

十四、全部代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;

class String
{
public:
	typedef char* iterator;
	typedef const char* const_iterator;
	String(const char* str = "")
		:_size(strlen(str))
	{
		_capacity = _size == 0 ? 4 : _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	String(const String& s)
		:_size (s._size)
		,_capacity(s._capacity)
	{
		_str = new char[_capacity + 1];
		strcpy(_str, s._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;
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
	}
	const char* c_str()
	{
		return _str;
	}
	const char& operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}
	iterator begin()
	{
		return _str;
	}
	iterator end()
	{
		return _str + _size;
	}
	const_iterator begin() const
	{
		return _str;
	}
	const_iterator end() const 
	{
		return _str + _size;
	}
	size_t size() const
	{
		return _size;
	}
	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 || s == *this;
	}
	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);
	}
	void reserve(size_t n)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
	void resize(size_t n,char c)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		while (n-_size-1)
		{
			tmp[_size] = c;
			_size++;
		}
		delete[] _str;
		_str = tmp;
		_capacity = n;
		++_size;
		_str[_size] = '\0';
		
	}
	void push_back(char ch)
	{
		if (_size + 1 > _capacity)
		{
			reserve(_capacity * 2);
		}
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}
	void append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}
	String& operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}

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

		size_t end = _size;
		while (end > pos)
		{
			--end;
		}
		while (end < _size + 1)
		{
			_str[end ] = _str[end+1];
			end++;
		}
		_size--;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

void Test1()
{
	String s1;
	String s2("Hello word!");
	String const s3(s2);
	s1 = s2;
	cout << s2.c_str() << endl;
	cout << s2[4] << endl;
	String::iterator it = s2.begin();
	while (it != s2.end())
	{
		*it = 'a';
		cout << *it;
		it++;
	}
	cout << endl;

	String::const_iterator it2 = s3.begin();
	while (it2 != s3.end())
	{
		cout << *it2;
		it2++;
	}
	cout << endl;
	for (auto it3 : s2)
	{
		cout << it3;
	}
	cout << endl;
	cout << s2.size() << endl;
	cout << (s1 < s2) << endl;
	cout << (s1 > s2) << endl;
	cout << (s1 <= s2) << endl;
	cout << (s1 >= s2) << endl;
	cout << (s1 != s2) << endl;
	cout << (s1 == s2) << endl;
	s1.reserve(30);
	s1.push_back('a');
	cout << s1.c_str() << endl;
	s1.resize(40, 'c');
	cout << s1.c_str() << endl;
	s2.append("dddd");
	cout << s2.c_str() << endl;
	s2 += "bbbbbbb";
	s2 += 'c';
	cout << s2.c_str() << endl;
	s2.insert(2, 'q');
	cout << s2.c_str() << endl;
	s2.erase(2);
	cout << s2.c_str() << endl;
}

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

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/517462.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

单例(Singleton)设计模式

单例(Singleton)设计模式

2.1 设计模式概述 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱&#xff0c;不同的棋局&#xff0c;我们用不同的棋谱。"套路" 经典的设计模式共有23种。每个…
阅读更多...
linux基础篇：linux挂载本地yum源——centos7.9为例

linux基础篇：linux挂载本地yum源——centos7.9为例

linux挂载本地yum源——centos7.9为例 一、Linux本地yum源介绍 Linux本地YUM源是一个本地存储的软件包仓库&#xff0c;它允许用户在不连接互联网的情况下安装、更新和管理软件包。本地YUM源可以提高软件包安装速度&#xff0c;降低网络带宽消耗&#xff0c;并提高软件包管理…
阅读更多...
隐私计算实训营学习七：隐语SCQL的架构详细拆解

隐私计算实训营学习七：隐语SCQL的架构详细拆解

文章目录 一、SCQL Overview1.1 SCQL背景1.2 SCQL Overview 二、SCQL CCL三、SCQL架构 一、SCQL Overview 1.1 SCQL背景 SCQL&#xff1a;属于隐私计算BI范畴&#xff0c;允许多个互不信任参与方在不泄露各自隐私数据的条件下进行联合数据分析。 如下数据在不同机构&#xf…
阅读更多...
【机器学习】如何通过群体智慧解决机器学习的挑战“

【机器学习】如何通过群体智慧解决机器学习的挑战“

机器学习的发展日新月异&#xff0c;但其成功实施的关键之一仍然是获取高质量的、标注良好的数据集。在这篇文章中&#xff0c;我们将探讨如何通过群体智慧来构建和改善机器学习的数据集&#xff0c;尤其是通过reCAPTCHA和带有目的的游戏&#xff08;Games with a Purpose, GWA…
阅读更多...
深度学习-计算机视觉入门-part1

深度学习-计算机视觉入门-part1

计算机视觉入门 文章目录 计算机视觉入门一、 从卷积到卷积神经网络1.图像的基本表示2. 卷积操作3.卷积遇见深度学习3.1 通过学习寻找卷积核3.2 参数共享&#xff1a;卷积带来参数量骤减3.3 稀疏交互&#xff1a;获取更深入的特征 二、手撕卷积代码三、经典CNN模型介绍四、CNN模…
阅读更多...
【一】web框架的本质

【一】web框架的本质

模板文件和静态文件 ​ 模板文件和静态文件是在 web 开发中常用的两种资源文件&#xff0c;用于构建网站和 web 应用。 模板文件&#xff1a;模板文件是用于定义网页结构和内容的文件。 它们通常使用模板引擎&#xff08;例如Jinja2或Django模板&#xff09;来插入动态数据&a…
阅读更多...
【算法练习】28：选择排序学习笔记

【算法练习】28：选择排序学习笔记

一、选择排序的算法思想 弄懂选择排序算法&#xff0c;先得知道两个概念&#xff1a;未排序序列&#xff0c;已排序序列。 原理&#xff1a;以升序为例&#xff0c;选择排序算法的思想是&#xff0c;先将整个序列当做未排序的序列&#xff0c;以序列的第一个元素开始。然后从左…
阅读更多...
scala实现通过Spark统计人均登录次数最终写入MySQL

scala实现通过Spark统计人均登录次数最终写入MySQL

谨以此博客作为记录 小编这里用的版本是&#xff1a; <hadoop.version>2.7.7</hadoop.version> <spark.version>2.4.5</spark.version> <scala.version>2.12.10</scala.version> 如果没用到Hadoop可以忽略 步骤 准备数据&#xff0c;知道…
阅读更多...
【Latex】参考文献标号未对齐解决方案

【Latex】参考文献标号未对齐解决方案

Latex写论文时发现最后参考文献标号出现如下没有对齐的情况&#xff1a; 解决方案&#xff1a; 将参考文献开始出的序号1改为99&#xff08;或者其他大点的数字也可以&#xff09; ⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇
阅读更多...
JSON的定义和基本使用

JSON的定义和基本使用

1、JSON的特点: JSON是一种轻量级的数据交换格式&#xff0c;是由字符串化的键值对构成。基于网络的前后端通信&#xff0c;数据在服务端和客户端之间进行传输&#xff0c;采用的就是JSON的格式来进行交互。JSON采用完全独立于语言的文本格式&#xff0c;JSON的数据格式完全独…
阅读更多...
HarmonyOS（鸿蒙）——单击事件

HarmonyOS（鸿蒙）——单击事件

2.4 实现ClickedListener接口并重写onClick方法 2.5 实现onClick方法中的具体逻辑&#xff0c;以此完成点击事件的相关业务操作 三、测试 3.1 登录远程模拟器 3.2 运行项目 四、精选好文 一、简介 1.1 什么是组件 组件就是文本、按钮、图片等元素的统称 1.2 什么是事件 …
阅读更多...
【测试篇】测试用例

【测试篇】测试用例

文章目录 前言具体设计测试用例等价类边界值场景设计法判定表&#xff08;因果图&#xff09;正交排列&#xff08;用的非常少&#xff09;错误猜测法 前言 什么是测试用例&#xff1f;&#xff1f; 测试用例是针对软件系统或应用程序的特定功能或场景编写的一组步骤&#xf…
阅读更多...
了解 Solidity 语言：构建智能合约的首选编程语言

了解 Solidity 语言：构建智能合约的首选编程语言

了解 Solidity 语言&#xff1a;构建智能合约的首选编程语言 Solidity 是一种用于编写智能合约的高级编程语言&#xff0c;广泛应用于以太坊和其他以太坊虚拟机&#xff08;EVM&#xff09;兼容的区块链平台。它是以太坊智能合约的首选语言之一&#xff0c;具有丰富的功能和灵活…
阅读更多...
GEE教程——如何利用影像行列号和distinct函数实现影像的筛选

GEE教程——如何利用影像行列号和distinct函数实现影像的筛选

如何利用影像行列号和distinct函数实现影像的筛选 本次主要利用Landsat中 WRS_PATH 和 WRS_ROW属性实现对影像的筛选。这里我们会用到遍历函数map也就是我们需要对其影像中的每一景影像的行列号属性进行获取，然后再对其列表化，然后利用distinct函数实现属性分离，最后移除不…
阅读更多...
Coursera上托福专项课程01：TOEFL Reading and Listening Sections Skills Mastery 学习笔记

Coursera上托福专项课程01：TOEFL Reading and Listening Sections Skills Mastery 学习笔记

TOEFL Reading and Listening Sections Skills Mastery Course Certificate 本文是学习 https://www.coursera.org/learn/toefl-reading-listening-sections-skills-mastery 这门课的笔记&#xff0c;如有侵权&#xff0c;请联系删除。 文章目录 TOEFL Reading and Listening …
阅读更多...
【系统架构师】-软件产品线与构件

【系统架构师】-软件产品线与构件

1、产品线 核心资源、产品集合 1、过程驱动 2、特定领域 3、技术支持 4、以架构为中心 双生命周期模型&#xff1a; 建立产品线的方式&#xff1a;演化、革命 成功因素&#xff1a; 对该领域具备长期和深厚的经验 一个用于构建产品的好的核心资源库 好的产品线架构 好的管…
阅读更多...
STM32CubeMX 中配置__weak类型函数和用法

STM32CubeMX 中配置__weak类型函数和用法

目录 概述 1 weak类型函数 1.1 weak类型函数介绍 1.2 weak类型函数的特点 2 在 STM32CubeMX中配置weak类型函数 2.1 配置函数类型 2.2 生成代码 2.3 验证 3 _weak类型函数项目中的应用 3.1 重写_weak类型函数 3.2 测试 4 总结 概述 本文主要介绍__weak类型函数…
阅读更多...
java算法day44 | 动态规划part06 ● 完全背包 ● 518. 零钱兑换 II ● 377. 组合总和 Ⅳ

java算法day44 | 动态规划part06 ● 完全背包 ● 518. 零钱兑换 II ● 377. 组合总和 Ⅳ

完全背包理论基础 完全背包和01背包问题唯一不同的地方就是&#xff0c;每种物品有无限件。 体现在代码中就是对背包的遍历顺序不同。01背包是逆序遍历背包&#xff0c;完全背包是顺序遍历背包。 518. 零钱兑换 II class Solution {public int change(int amount, int[] coin…
阅读更多...
接口调用成功后端却一直返回404

接口调用成功后端却一直返回404

vuespringboot 我在vue.config.js中配置了向后端的反向代理 然后使用了axios向后端发送post请求 可以看到可以接收到前端传来的值 但是前端控制台却报了 “xhr.js:245POST http://localhost:7777/api/login 404 (Not Found)” 最后询问我那智慧的堂哥... ... 解决办法是把C…
阅读更多...
Flutter Boost 3

Flutter Boost 3

社区的 issue 没有收敛的趋势。 设计过于复杂&#xff0c;概念太多。这让一个新手看 FlutterBoost 的代码很吃力。 这些问题促使我们重新梳理设计&#xff0c;为了彻底解决这些顽固的问题&#xff0c;我们做一次大升级&#xff0c;我们把这次升级命名为 FlutterBoost 3.0&am…
阅读更多...
最新文章

Copyright @ 2022~2023