【C++】-8.2- string〔string类模拟实现〕

最新推荐文章于 2024-07-08 21:23:20 发布
最新推荐文章于 2024-07-08 21:23:20 发布
阅读量549 收藏
点赞数
分类专栏： C++ 文章标签： c++ 数学建模 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fantastic_13_7/article/details/131308727
版权

文章目录

//模拟实现string类，并完成测试

头文件声明：

//anolog_string.h
#pragma once

#include <iostream>
namespace RoundBottle//与库里面的string类做区分
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		//全缺省构造
		string(const char* str = "");

		//拷贝构造
		string(const string& s);

		//赋值重载是关于两个已经存在的对象
		string& operator=(const string& s);
		~string();

		/

		// access
		char& operator[](size_t index);
		const char& operator[](size_t index)const;

		//

		// iterator
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		/

		// modify
		void push_back(char c);

		string& operator+=(char c);

		void append(const char* str);
		string& operator+=(const char* str);

		void clear();
		void swap(string& s);
		const char* c_str()const;

		/

		// capacity
		size_t size()const;
		size_t capacity()const;
		bool empty()const;
		void resize(size_t n, char c = '\0');
		void reserve(size_t n);

		/

		//relational operators
		bool operator<(const string& s);
		bool operator<=(const string& s);
		bool operator>(const string& s);
		bool operator>=(const string& s);
		bool operator==(const string& s);
		bool operator!=(const string& s);

		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const;

		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const;

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c);
		string& insert(size_t pos, const char* str);

		// 删除pos位置上的元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len = npos);

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

	size_t string::npos = -1;

	std::ostream& operator<<(std::ostream& _cout, const RoundBottle::string& s);
	std::istream& operator>>(std::istream& _cin, RoundBottle::string& s);

	//测试
	void string_test()
	{}
};

//test.cpp
#include "analog_string.h"

int main()
{
	try
	{
		RoundBottle::string_test();
	}
	catch (const std::exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

• string类的基本结构

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

在这里插入图片描述

• Destructor

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

• Construct

〔构造函数〕

‹ 无参构造 ›

  • 方式一：_str 置空指针
//全缺省构造
string()
	: _str(nullptr)
	, _size(0)
	, _capacity(0)
	{}

//cout 自动识别类型，对于指针，会进行解引用！

cout << s.c_str() <<endl; 👉 s.c_str()成员函数 会返回对象 s 中的成员变量 _str，若 _str==nullptr 则 cout 会对空指针进行解引用！

  • 方式二：给_str所指向的空间开新空间——new char
//全缺省构造
string()
	: _str(new char)
	, _size(0)
	, _capacity(0)
	{}

//析构函数执行的语句是：delete [] _str; 与 new 不匹配（关于new和delete详见文章C++ -5- 内存管理）

  • 方式三：_str = new char [1]
//全缺省构造
string()
	: _str(new char [1])
	, _size(0)
	, _capacity(0)
	{
		_str[size] = '\0';
	}

‹ 单参数构造 ›

  • 方式一：直接赋值
//全缺省构造
string(const char* str)
	: _str(str)//权限放大
	, _size(strlen(str))
	, _capacity(strlen(str))
	{}

将 str 中的地址赋值给 _str 很明显是权限放大，如下图：
在这里插入图片描述

  • 方式二：
//全缺省构造
string(const char* str)
	: _size(strlen(str))
{
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}
  • 关于 capacity：
    • 能存多少个有效数据（不包括’\0’）→ 所以开空间要多开一个留给’\0’
    • 尽量不要再初始化列表里面用 size 来初始化 capacity，因为初始化的顺序是变量声明的顺序，变量声明顺序更改会影响初始化的结果。

‹ 全缺省参数构造 ›

无参构造和单参数构造可以合成一个全缺省参数构造

//全缺省构造
string(const char* str = "")
	: _size(strlen(str))
{
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}
  • "" 常量字符串默认以 ‘\0’ 结束 （字符串为不为空都是如此）
  • const char* str = '\0' 不可以！ ‘\0’ 只是一个 char 类型的字符，将 char 类型的数据赋值给 const char* 类型不匹配，会发生类型转换，char 类型转化为 int 类型，类型仍然不匹配，则 str 会被赋值为空指针。
  • “\0”才是一个常量字符串
  • const char* str = "" == const char* str = "\0"

〔拷贝构造〕

开新空间 + 拷贝数据

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

• operator= 赋值重载

  • delete 原空间
    • 自己赋值给自己（ s = s ）？自己给自己 delete 之后就什么都没了~，所以如果是自己给自己赋值，这里需要判断一下，什么也不执行就行了。
  • new 新空间
    • 为了防止开空间失败，这个可以先创建临时变量
  • strcpy 内容到新空间
  • 修改 size 和 capacity

❗❗赋值重载是关于两个已经存在的对象

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

• Element access（operator[]）

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

补充：const 变量的场景

const 变量不可以调用非 const 成员函数，不修改成员函数变量数据的函数最好都加 const
例如如下代码：参数为 const string 类型

const char& operator[](size_t index)const
{
	assert(index < _size);
	return _str[index];
}
size_t size()const
{
	return _size;
}
void Print(const string& s)
{
	for (int i = 0; i < s.size(); ++i)//size()
	{
		cout << s[i] << " ";//[]操作符重载
	}
	cout << endl;
}

• Iterator

这里用指针来模拟实现迭代器，但库中的迭代器不一定都是用指针实现的。

另外，begin() 和 end() 遵循 “左闭右开” 的原则。
在这里插入图片描述

typedef char* iterator;
typedef const char* const_iterator;

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

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

实现了迭代器之后，范围for也可以用。

应用示例：

void string_test6()
{
	string s("abcdefghijklm");

	string::iterator it = s.begin();	
	while (it != s.end())
	{	
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	for(auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

• Relational Operators（比较大小）

比较ASCII码值的大小，复用 strcmp

bool operator<(const string& s)
{
	return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s)
{
	return strcmp(_str, s._str) <= 0;
}
bool operator>(const string& s)
{
	return !(*this <= s);
}
bool operator>=(const string& s)
{
	return !(*this < s);
}
bool operator==(const string& s)
{
	return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s)
{
	return !(*this == s);
}

• Capacity

〔size〕&〔capacity〕&〔empty〕

size_t size()const
{
	return _size;
}
size_t capacity()const
{
	return _capacity;
}
bool empty()const
{
	return _size == 0;
}

〔reserve〕

  • reverse 是管理容量的函数
  • 不缩容原则，如果要更改的容量大小小于原容量大小则不执行操作
  • 实现思路：
    • 按指定容量大小开新空间（永远多开一个位置给’\0’）
    • 拷贝数据到新空间
    • 释放原空间
    • 新空间地址赋值给 _str
    • 修改容量大小
void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[]_str;
		_str = tmp;
		_capacity = n;
	}
}

〔resize〕

  • resize ：开空间（size_t n） + 初始化（char c）
  • if (n <= _size) 容量不缩，只保留前 n 个数据
  • if (n > _capacity) 扩容
  • ps. size >= capacity
void resize(size_t n, char c = '\0')
{
	if (n <= _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		if (n > _capacity)
		{
			reserve(n);
		}
		int cout = n - _size;
		while (cout--)
		{
			_str[_size] = c;
			++_size;
		}
		_str[_size] = '\0';
	}
}

• Modify

〔push_back〕&〔append〕

插入数据就要考虑容量问题，势必要进行扩容，由于原本的空间就是 new 出来的，扩容肯定不能用 realloc 直接扩容，所以最终我们选择手动扩容 → 调用 reserve 函数
在这里插入图片描述
整体思路：

  • 检查容量
  • 插入数据
  • 修改 _size
void push_back(char c)
{
	if (_size == _capacity)
	{
		//扩容
		int new_capacity = _capacity == 0 ? 7 : _capacity * 2;
		reserve(new_capacity);
	}
	_str[_size] = c;
	++_size;
	_str[_size] = '\0';
}

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

〔+=〕

复用 push_back 和 append

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


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

〔swap〕

可以复用 std 库里的 swap 函数

void swap(string& s)
{
	/*char* ptmp = _str;
	_str = s._str;
	s._str = _str;

	char size = _size;
	_size = s._size;
	s._size = _size;

	char capacity = _capacity;
	_capacity = s._capacity;
	s._capacity = _capacity;*/

	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

〔clear〕& 〔c_str〕

clear ：清空数据

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

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

• 「insert」在 pos 位置插入字符或字符串

插入字符就相当于插入只有单个字符的字符串，所以这里详细分析插入字符串时的情况，插入字符的思路与之类似。

基本思路：①检查容量；②挪动数据（strncpy）；③插入数据。（注意检查 pos 位置的有效性）

如下图，在 pos 位置插入长度为 len 的字符串：则我们需要把 红色区域 的数据往后挪动 len个单位长度，再将要插入的数据从原 pos 位置往后依此插入。
在这里插入图片描述

  • 可以选择 index 从 size 位置开始吗？？👉不可以
    当 pos == 0 时情况如下：
    在这里插入图片描述
    ①size_t index 是无符号整型，-1即为整型的最大值，以 index >= pos 作为循环判断条件，在 pos ==0 的情况下将进入死循环；
    ②若声明 int index，仍以 index >= pos 作为循环判断条件，>=操作符左右变量的类型不同，会发生类型转换，通常是比较范围小的向范围大的转换，即在该情况下，有符号整型一般转化为无符号整型。

简单说明一下strnpy函数：strncpy( dst-copy到哪 , scr-从哪copy , 从scr copy 多少个)

string& insert(size_t pos, char c)
{
	assert((pos <= _size) && (pos >= 0));
	if (_size + 1 > _capacity)//扩容
	{
		int new_capacity = _capacity == 0 ? 7 : _capacity * 2;
		reserve(new_capacity);
	}

	for (size_t index = _size + 1; index >= pos + 1; --index)//挪动数据
	{
		_str[index] = _str[index - 1];
	}
	_str[pos] = c;
	++_size;
	return *this;
}

string& insert(size_t pos, const char* str)
{
	assert((pos <= _size) && (pos >= 0));
	int len = strlen(str);
	if (_size + len > _capacity)//扩容
	{
		int new_capacity = _size + len;
		reserve(new_capacity);
	}

	for (int index = _size + len; index >= pos + len; --index)//挪动数据
	{
		_str[index] = _str[index - len];
	}

	strncpy(_str + pos, str, len);
	_size += len;

	return *this;
}

• 「erase」从 pos 位置删除 len 个字符

  1. pos 往后还有 >= len 个长度的字符：挪动覆盖数据（memmove/strcpy）
  2. pos 往后不足 len 个长度的字符：从 pos 往后全部删除（包括 pos 位置的数据）

注意：pos + len >= _size || len == npos len == npos必须单独判断，npos 已经是整型的最大值。

string& erase(size_t pos, size_t len = npos)
{
	assert((pos < _size) && pos);
	if (pos + len >= _size || len == npos)
	{
		_size = pos;
		_str[_size] = '\0';
	}
	else
	{
		for (size_t index = pos + len; index <= _size; ++index)
		{
			_str[index - len] = _str[index];
		}
		//strcpy(_str+pos,_str+pos+len)
		_size -= len;
	}
	return *this;
}

注：npos的声明和定义

class string
{
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
		static size_t npos;
		//static size_t npos = -1;error
};
size_t string::npos = -1;

静态成员变量：类内声明，类外定义。
（ps. C++中加 const 的静态成员变量可以给缺省值，但是只针对整型变量）（最好不要这么用）

class string
{
	private:
		const static size_t npos = -1;
};

• 「find」

  • 找字符：找到就返回该字符下标，没有找到返回 npos
  • 找字串：strstr函数暴力匹配
    • 为 nullptr 即没找到
    • 找到返回子串第一个字符的地址 👉 地址 - 地址 = 下标
//找字符c
size_t find(char c, size_t pos = 0) const
{
	for (int i = 0; i < _size; ++i)
	{
		if (_str[i] == c)
			return i;
	}
	return npos;
}

//找字串s
size_t find(const char* s, size_t pos = 0) const
{
	char* p = strstr(_str, s);
	if (p == nullptr)
	{
		return npos;
	}
	else
	{
		return (p - _str);
	}
}

• 「流插入<<、流提取>>」

肯定不能写成成员函数，可以用友元函数，但也不一定要写成友元函数。

‹ 流插入 ›

  • 流插入重载要根据 size 打印，即使字符串间夹杂着 ‘\0’
  • 不能直接访问成员变量，可以通过成员函数间接访问。（ iterator / 范围for / [下标] ）
std::ostream& operator<<(std::ostream& _cout, const RoundBottle::string& s)
{
	for (auto e : s)
	{
		_cout << e;
	}
	return _cout;
}

‹ 流提取 ›

cin 和 scanf 对于空格和换行不识别 👉 采用 istream 的成员函数 get()

优化：不断输入字符会导致频繁的扩容，这里可以用一个临时数组储存输入字符，临时数组每满一次就追加到 string s 中，知道输入结束后，将临时数组里剩下的字符再追加到 string s 中。

std::istream& operator>>(std::istream& _cin, RoundBottle::string& s)
{
	s.clear();
	char tmp[128];
	char c = _cin.get();
	int index = 0;
	while (c != '\0' && c != '\n')
	{
		tmp[index] = c;
		++index;

		if (index == 127)
		{
			tmp[index] = '\0';
			s += tmp;
			index = 0;
		}
		c = _cin.get();
	}
	if (index != 0)
	{
		tmp[index] = '\0';
		s += tmp;
	}
	return _cin;
}

END

畋坪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
高质量C++-C编程指南
10-15
9.8 如何在派生类中实现类的基本函数... 75 file:///D|/My Documents/学习/高质量C++-C编程指南.txt[2008-11-11 21:48:26] 9.9 一些心得体会... 77 第10章 类的继承与组合... 78 10.1 继承... 78 10.2 组合... 80 第...
多项式类的C++实现
07-25
文件构造了一个较完整的多项式类，可以实现多项式的常用运算： 1、可通过　Poly P 声明一个多项式 P； 2、可通过　P.read(string P_str) 直接从 手写习惯的多项式字符串 读入多项式； 3、可通过 P.newTerm(double ...
调用String对象的toString()方法时报空指针异常
huidoo888的博客
07-13 9572
为什么有时候用String对象，去调用的toString()方法时报空指针异常（java.lang.NullPointerException），其原因是我们的创建的String类对象为null；这样就不能再去调用toString方法啦。
C++string类模拟实现
fight_p的博客
08-20 233
本文详细实现了string类各种接口，并且对有些容易写错的代码，做了详细解释，并介绍拷贝构造函数和赋值运算符重载函数两种现代写法。
【C++/STL】：string类底层的模拟实现
2301_77900444的博客
05-17 696
但是这种写法不仅适用于string类，后面的链表，树也同样适用。因为链表，树等要拷贝节点，不容易进行深拷贝。上一篇文章已经对string类进行了简单的介绍，大家只要能够正常使用即可。这篇文章主要是对string类的几个重点的基本接口函数进行模拟实现，而这几个函数的模拟也有可能出现在面试中。
【C++】string类的模拟实现
weixin_74078718的博客
04-01 1704
string类的模拟实现
高质量C++-C编程指南.htm
08-20
9.8 如何在派生类中实现类的基本函数... 75 9.9 一些心得体会... 77 第10章 类的继承与组合... 78 10.1 继承... 78 10.2 组合... 80 第11章 其它编程经验... 82 11.1 使用const提高函数的健壮性... 82 11.2 ...
via-httplib:用于在 C++ 应用程序中嵌入 HTTP 或 HTTPS 服务器的库
05-30
它已经过MSVC 2017 、 Clang 7.0.1 、 GCC 8.2和MinGw 7.3.0 。 C++11 版本在标签1.6.0及更低版本中可用。 asio C++ 库。 或 。 对于：多线程、身份验证和/或请求路由器，需要相关的库。 但是，如果不需要它们，...
C++ 标准 ISO 14882－2011
05-26
1.7 The C++ memory model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.8 The C++ object model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 629
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c++习题08-计算星期几
码到成龚的博客
07-03 597
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 914
Android 开发中 C++ 和Java 日志调试方法小结
机器人运动范围检测 c++
m0_61862494的博客
07-02 764
地上有一个m行n列的方格，一个机器人从坐标（0，0）的格子开始移动，它每次可以向上下左右移动一个格子，但不能进入行坐标和列坐标的位数之和大于k的格子，请问机器人能够到达多少个格子。这个算法的时间复杂度为O(mn)，其中m和n分别是网格的行数和列数。空间复杂度也是O(mn)，主要用于存储visited数组和BFS队列。这个实现使用了广度优先搜索（BFS）算法来解决问题。
数学系C++ 继承派生多态 （十四十三）
最新发布
m0_68339197的博客
07-08 215
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 252
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
c++习题09-分离整数的各个数
码到成龚的博客
07-04 223
描述 给定一个整数n(1≤n≤100000000)，要求从个位开始分离出它的每一位数字。从个位开始按照从低位到高位的顺序依次输出每一位数字。 输入描述 输入一个整数，整数在1到100000000之间。 输出描述 从个位开始按照从低位到高位的顺序依次输出每一位数字。数字之间以一个空格分开。
c++初级-2-引用
ccb1372098的博客
07-02 416
int a = 10;//引用int& b = a;b = 20;cout << "修改后" << endl;/***输出结果：a = 10b = 10修改后a = 20b = 20**/引用要求引用必须初始化。引用之后，不可以更改引用的对象。
WPF UI 3D 多轴 机械臂 stl 模型UI交互
cao919的专栏Net
07-02 421
鼠标交互（没有强调场景的变换）鼠标命中测试（HitTest 不推荐）平面对象加载数据绑定（数据与动作）顶部控件多轴控制uiui后端效果。
gradle-8.2-bin.zip
01-18
gradle-8.2-bin.zip 是一个用于构建和管理项目的工具，它是一个Java开发工具包。这个压缩包包含了Gradle 8.2版本的二进制可执行文件，可以通过下载并解压来安装Gradle。 Gradle 是一个开源的构建自动化工具，它使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

畋坪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值