字符串类运算符重载

最新推荐文章于 2023-10-10 21:15:00 发布
最新推荐文章于 2023-10-10 21:15:00 发布
阅读量1.5k 收藏 14
点赞数 1
分类专栏： C++ 文章标签： C++ 学习笔记 char 数组类运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FAKER_0X0/article/details/89350914
版权

C++字符串类运算符重载

//重点

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//定义MyString类 字符串数组
class MyString
{
public:
	//构造和析构函数
	MyString()
	{
		m_len = 0;
		m_p = NULL;
	}
	//MyString(int len = 0)
	//{
	//	if (len < 0) {
	//		m_len = 0;
	//		return;		//直接返回到main函数
	//	}
	//	m_len = len;
	//	m_p = new char[len + 1];
	//}
	MyString(const char *p)		//MyString a(“dddd”);需要能实现这样的初始化
	{
		m_len = strlen(p);
		m_p = new char[m_len + 1];
		strcpy(m_p, p);
	}

	MyString(const MyString& obj)	//拷贝构造函数，先释放旧内存
	{
		if (obj.m_len > 0) {	//	长度大于0才需要拷贝
			m_len = obj.m_len;
			m_p = new char[m_len + 1];
			strcpy(m_p, obj.m_p);	//复制字符串内容
		}
	}
	~MyString()
	{
		if (m_p != NULL) {
			delete[] m_p;
			m_len = 0;
		}
	}
	//运算符重载
	char& operator[](int i)
	{
		return m_p[i];
	}
	MyString& operator=(MyString& s)
	{
		if (m_p != NULL) {
			delete[] m_p;
			m_len = 0;
		}
		m_len = s.m_len;
		m_p = new char[m_len + 1];
		strcpy(m_p, s.m_p);
		return *this;
	}
	//重载=运算符后再重载这个函数是否可行？		证明可行
	MyString& operator=(const char *p)	//s1 = "ddddd";需要能实现这样的赋值
	{
		m_len = strlen(p);
		m_p = new char[m_len + 1];
		strcpy(m_p, p);
		return *this;
	}

	bool operator==(MyString& s)
	{
		if (m_len != s.m_len) {
			return false;
		}													
		for (int i = 0; i < m_len; ++i) {						
			if (m_p[i] != s[i]) {
				return false;
			}
		}
		return true;
	}
	bool operator!=(MyString& s)
	{
		return !(*this == s);
	}

	bool operator>(MyString& s)	//实现链式编程，返回值为引用?还是bool?
	{
		if (strcmp(m_p, s.m_p) > 0) {
			return true;
		}
		else {
			return false;
		}
	}
	bool operator<(MyString& s)
	{
		return !(*this > s);
	}

	friend ostream& operator<<(ostream& out, MyString& s);
	friend istream& operator>>(istream& in, MyString& s);

private:
	int m_len;
	char *m_p;
};

ostream& operator<<(ostream& out, MyString& s)
{
	cout << "The string is: " << endl;
	for (int i = 0; i < s.m_len; ++i) {
		out << s[i];
	}
	return out;
}
istream& operator>>(istream& in, MyString& s)
{
	cout << "Please input " << s.m_len << " characters: " << endl;
	for (int i = 0; i < s.m_len; ++i) {
		in >> s[i];
	}
	return in;
}

int main()
{
	MyString s1("ddddd"),s2;
	//cin >> s1;
	//s1[3] = 'f';	//这个实现了？
	cout << s1 << endl;

	s2 = "zzzzz";		//这个如何实现？
	cout << s2 << endl;

	if (s1 < s2) {
		cout << "s1 < s2" << endl;
	}
	else {
		cout << "s1 > s2" << endl;
	}

	s2 = s1;
	cout << s2 << endl;

	if (s1 == s2) {
		cout << "s1 == s2" << endl;
	}
	else {
		cout << "s1 != s2" << endl;
	}

	cout << s2[1] << endl;

	return 0;	//以上运算符重载调试成功！
}

注意点：

  1. 要支持空串“”
  2. 实参 “zzzzz” 应该对应形参 const char *p
  3. strlen在参数为NULL情况下会出错，只能在strlen使用之前先判断一下
  4. 重载 = 运算符对应两种参数情况，s1 =s2; s1 = “ddddd”;
  5. out << s.m_p; 重载 << 运算符的优化，可以直接输出属性，不需使用循环输出字符数组
  6. 重载 == 和！=也对应两种参数情况
  7. C++里边只要是非零都认为是真，只有在值为0的时候才认为是假。重载 == 时使用 return !strcmp(m_p,p); 可以代替对字符数组每个值的比较。
  8. 重载 == 和！=运算符的函数定义后面加 const 表示不可更改指针指向的内存数据。
  9. 重载 > 和 < 运算符也对应两种参数情况，可直接使用return strcmp(m_p, s.m_p); 和 return strcmp(s.m_p, m_p); ，调换两个参数的位置
  10. 有时需要把类的指针 露出来，strcpy(s3.c_str(), “aaaa”); 这样用函数调用 （对比MFC）
  11. MyString s4; cin >> s4; //注意：此时s4调用无参构造函数，由于指针没有分配内存，无法输入数据，程序直接跳过；解决方案：声明另外的有参构造函数 MyString(int len = 0)
  12. 重载 >> 和 << 运算符可以直接使用 in >> s.m_p; out << s.m_p; 而不使用循环输出字符数组，不然有时会出现意想不到的问题。

完善和优化后的代码：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//定义MyString类 字符串数组
class MyString
{
public:
	//重载 >> 和 << 运算符
	friend ostream& operator<<(ostream& out, MyString& s);
	friend istream& operator>>(istream& in, MyString& s);

	//构造和析构函数
	//MyString()		//完善：要支持空串“”
	//{
	//	m_len = 0;
	//	//m_p = NULL;
	//	m_p = new char[m_len + 1];
	//	strcpy(m_p, "");
	//}

	MyString(int len = 0)
	{
		if (len == 0) {
			m_len = 0;
			m_p = new char[m_len + 1];
			strcpy(m_p, "");
		}
		else {
			m_len = len;
			m_p = new char[m_len + 1];
			strcpy(m_p, "");
		}
	}

	//MyString(int len = 0)		//和上面的例程没差别吧？
	//{
	//	if (len < 0) {
	//		m_len = 0;
	//		return;		//直接返回到main函数
	//	}
	//	m_len = len;
	//	m_p = new char[len + 1];
	//}

	MyString(const char *p)		//MyString a(“dddd”);需要能实现这样的初始化
	{
		if (p == NULL) {	//完善：要支持MyString s3 = NULL;不加这个编译会出现断点
			m_len = 0;
			m_p = new char[m_len + 1];
			strcpy(m_p, "");
		}
		else {
			m_len = strlen(p);	// strlen在参数为NULL情况下会出错
			m_p = new char[m_len + 1];
			strcpy(m_p, p);
		}
	}

	MyString(const MyString& obj)	//拷贝构造函数，先释放旧内存
	{
		if (obj.m_len > 0) {	//	长度大于0才需要拷贝
			m_len = obj.m_len;
			m_p = new char[m_len + 1];
			strcpy(m_p, obj.m_p);	//复制字符串内容
		}
	}
	~MyString()
	{
		if (m_p != NULL) {
			delete[] m_p;
			m_p = NULL;	//完善
			m_len = 0;
		}
	}
	//运算符重载
	char& operator[](int i)
	{
		return m_p[i];
	}
	MyString& operator=(MyString& s)
	{
		if (m_p != NULL) {
			delete[] m_p;
			m_len = 0;
		}
		m_len = s.m_len;
		m_p = new char[m_len + 1];
		strcpy(m_p, s.m_p);
		return *this;
	}
	//重载=运算符后再重载这个函数是否可行？		证明可行
	MyString& operator=(const char *p)	//s1 = "ddddd";需要能实现这样的赋值
	{
		/*m_len = strlen(p);
		m_p = new char[m_len + 1];
		strcpy(m_p, p);
		return *this;*/
		if (m_p != NULL) {	//完善：1 先释放旧内存
			delete[] m_p;
			m_len = 0;
		}
		if (p == NULL) {	//2 分配新内存，要支持s1 = "";即空串
			m_len = 0;
			m_p = new char[m_len + 1];
			strcpy(m_p, "");	//3 复制内容
		}
		else {
			m_len = strlen(p);
			m_p = new char[m_len + 1];
			strcpy(m_p, p);
		}
		return *this;
	}

	bool operator==(MyString& s) const
	{
		if (m_len != s.m_len) {
			return false;
		}													
		/*for (int i = 0; i < m_len; ++i) {						
			if (m_p[i] != s[i]) {
				return false;
			}
		}
		return true;*/
		else {
			return !strcmp(m_p, s.m_p);	//优化：用字符串比较函数
		}
	}
	bool operator==(const char *p) const	//完善：要支持s3 == "dddd"判断
	{
		if (p == NULL) {
			if (m_len != 0) {
				return false;
			}
			else {
				return true;
			}
		}
		else {
			if (m_len != strlen(p)) {
				return false;
			}
			/*for (int i = 0; i < m_len; ++i) {
				if (m_p[i] != p[i]) {
					return false;
				}
			}*/
			else {
				return !strcmp(m_p, p);	//优化：用字符串比较函数
			}
		}
	}

	bool operator!=(MyString& s) const	//!= 也对应两种参数的情况
	{
		return !(*this == s);
	}
	bool operator!=(const char *p) const
	{
		return !(*this == p);
	}

	//bool operator>(MyString& s)	//实现链式编程，返回值为引用?还是bool?
	//{
	//	if (strcmp(m_p, s.m_p) > 0) {
	//		return true;
	//	}
	//	else {
	//		return false;
	//	}
	//}
	//bool operator<(MyString& s)
	//{
	//	return !(*this > s);
	//}

	int operator>(MyString& s)		//完善：大于和小于号的重载优化
	{
		return strcmp(m_p, s.m_p);
	}
	int operator>(const char *p)
	{
		return strcmp(m_p, p);
	}
	int operator<(MyString& s)
	{
		return strcmp(s.m_p, m_p);	//调换两个参数的位置
	}
	int operator<(const char *p)
	{
		return strcmp(p, m_p);
	}

	//把类的指针 露出来
	char *c_str()
	{
		return m_p;
	}
	const char *c_str2()	//指针指向的内存数据不可更改
	{
		return m_p;
	}
	int getLen()
	{
		return m_len;
	}

private:
	int m_len;
	char *m_p;
};

ostream& operator<<(ostream& out, MyString& s)
{
	cout << "The string is: " << endl;
	/*for (int i = 0; i < s.m_len; ++i) {
		out << s[i];
	}*/
	out << s.m_p;	//优化
	return out;
}
istream& operator>>(istream& in, MyString& s)
{
	cout << "Please input " << s.m_len << " characters: " << endl;
	/*for (int i = 0; i < s.m_len; ++i) {
		in >> s[i];
	}*/
	in >> s.m_p;	//优化
	return in;
}

int main()
{
	MyString s3 = NULL;
	s3 = "";
	if (s3 == "") {
		cout << "s3 == """ << endl;
	}
	else {
		cout << "s3 != """ << endl;
	}

	strcpy(s3.c_str(), "aaaa");
	cout << s3 << endl;

	MyString s4(5);
	cin >> s4;	//注意：此时s4调用无参构造函数，由于指针没有分配内存，无法输入数据，程序直接跳过
	cout << s4 << endl;		//注意：运行到这里会出现无法停止的问题！！此时把s3部分注释掉是可正常运行的
	

	//MyString s1("ddddd"),s2;
	cin >> s1;
	s1[3] = 'f';	//这个实现了？
	//cout << s1 << endl;

	//s2 = "zzzzz";		//这个如何实现？
	//cout << s2 << endl;

	//if (s1 < s2) {
	//	cout << "s1 < s2" << endl;
	//}
	//else {
	//	cout << "s1 > s2" << endl;
	//}

	//s2 = s1;
	//cout << s2 << endl;

	//if (s1 == s2) {
	//	cout << "s1 == s2" << endl;
	//}
	//else {
	//	cout << "s1 != s2" << endl;
	//}

	//cout << s2[1] << endl;

	return 0;	//以上运算符重载调试成功！
}
czopg
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串类，运算符重载
07-19
c++ 字符串类 运算符重载 动态内存 构造函数析构函数
C++ ------运算符重载：字符串和数组对象
lflcodeplus的博客
04-14 1269
C++ ------运算符重载：字符串和数组对象
C++中的运算符重载
今天你学习了吗？
01-17 844
以下为本人大一时阅读《C++ Primer Plus》中关于运算符重载章节所做的笔记 string类的重载运算符： 函数empty判断string是否为空 函数substr返回现有string的一部分 s.substr(a,b)返回将字符串s从下标a处开始截取长度为b的字符串 函数at返回string中位于指定下标处的字符 不能被重载的运算符： * :: ?: 运算符重载的规则和限制： 重载二元运算符： 尽管可以重载运算符"&" "&&a...
对字符串进行运算符重载
weixin_62802660的博客
05-04 1001
1、定义一个时间类Time，通过运算符重载实现时间的比较(关系运算)、时间增加/减少若干秒(+=和-=)、时间增加/减少1秒(++和--)、计算两个时间相差的秒数(-)以及输出时间对象的值(时—分—秒)。 class Time { friend int operator-(const Time &t1, const Time &t2); friend ostream &operator<<(ostream &os, const Time &amp...
类方法用字符串实现运算符的重载
qq_43824618的博客
10-25 420
运算符的重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 本代码实现的成员函数有构造函数、拷贝构造函数、=运算符、+运算符（类内实现对象加对象，对象加字符串，类外实现字符串加对象）、析构函数、<运算符、！=运算符、[ ]运算符、<<输出符（类外实现）。 两个类外实现的函数用了友元函数，类内由于有this指针，形参省略左面的，类外没有this指针，所以...
【C++】运算符重载案例 - 字符串类 ② ( 重载 等号 = 运算符 | 重载 数组下标 [] 操作符 | 完整代码示例 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-10 1048
一、重载 等号 = 运算符 1、等号 = 运算符 与 拷贝构造函数 2、重载 等号 = 运算符 - 右操作数为 String 对象 3、不同的右操作数对应的 重载运算符函数 4、重载 等号 = 运算符 - 右操作数为 字符串指针 二、重载 下标 [] 运算符 三、完整代码示例 1、String.h 类头文件 2、String.cpp 类实现 3、Test.cpp 测试类 4、执行结果
c++字符串重载运算符
08-26
字符串的重载运算符，用于对重载运算符机制的熟练掌握
字符串、运算符重载
10-16
赋值、相加、比大小、前++、后++ #include #include class String { private: int length; char *ptr; public: String(char *s); ~String(); String(String &s); void display(); String operator =(String &...
C++—运算符重载(1)
01-06
运算符重载功能很强大，可以方便很多操作 这些简单看一下它都有哪些用法： 比如，当我们要对两个字符串直接拼接在一起的时候，通常我们利用append()函数， 那能不能简单地直接用+号连接呢，类似于下面 ’ + ’ 号...
C++运算符重载
04-14
运算符重载 设计一个字符串类MyString，用函数重载机制实现对+、+=、==、int等运算符的重载，并实现对输入输出符号的重载。 
【C++】字符串中运算符的重载问题
weixin_45732589的博客
11-01 2044
字符串中运算符的重载问题 运算符的重载： 运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。 定义运算符重载函数的一般格式： 返回值类型 类名::operator重载的运算符(参数表){……} 在字符串中，运算符的重载问题在于字符串和字符串之间进行计算。 首先我们定义一个字符串的类，并为其写出构造函数、拷贝构造函数，析构函数、打印字符串函数。 class String { private: char
字符串类中重载运算符
talk is cheap;Later equals never;如果对你有帮助，点赞就行，没有建设性的建议请别留言:P
12-24 2147
测试程序 /// @file exam_1_1.cpp /** 1.完善MyString, 引用计数RefMyString operator= operator+ operator[](int nIndex) operator== operator!= operator> */ #include "common.h" #include "MyString.h" void fnTestStri
C ++中字符串类运算符重载示例
GJXAIOU 的 CSDN 博客
12-03 2050
一、基本概念 （一） 函数重载的含义 所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能，因此，一个函数名就可以用来代表不同功能的函数，也就是”一名多用”。 （二） 为什么要进行函数重载 一般情况下，编译器对现有操作符的操作数是有一定的限制，但是通常情况下用户使用class会自定义类型，而编译器是不认可这种类型的操作符运算的，所以可以将操作符进行重载达到可以根...
String 的 operator 运算符重载
周杰伦
08-17 2053
重载函数：同一作用域，同名不带形参的函数集。 重载运算符： 1、运算符只能针对基本类型 2、重载运算符拓展对复杂类型进行运算:重载运算符函数 &lt;返回类型&gt; operator&lt;运算符&gt;(形参列表) { } 3、运算符：sizeof, :: * -&gt; .不能重载 4、顺序性，结合性，数目不能改变 C++的堆区申请： 1、...
【C++ 】运算符重载
weixin_55664293的博客
03-22 4717
一、运算符重载的基本概念 我们知道C++预定义的运算符，只能用于基本数据类型的运算 如：整型，实型，字符型，逻辑型....... 运算符如：+、-、*、/、%、&、~、！、|、=、<<、>>、！=、..... 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 运算符重载的目的是：扩展C++中提供的运算符的适用范围，使之能作用于对象。 二、运算符重载的形式 1、运算符重载的实质是函数重载 2、可以重载为普通函数，也可以重载为成
C++之运算符重载
flyingcloud6的博客
10-01 824
这篇文章是c++的起步 写于2022.10.1
C++ 实现字符串类（重载运算符）
weixin_43731641的博客
07-07 2432
mystring.h #include<iostream> using namespace std; #ifndef MYSTRING_H #define MYSTRING_H class MyString { friend ostream& operator<<(ostream&out,MyString &ob);//友元函数重载<<的友元声明 friend istream& operator>>(istre
string类的模拟实现（五）—— 运算符重载
challenglistic的博客
04-06 1527
运算符 += 、 = 、>、[ ] 的重载实现
C++串类运算符重载程序类描述
06-11
在C++中，字符串是一种常见的数据类型，可以使用C++的串类来处理字符串。...在上述的C++串类中，使用了运算符重载函数来实现字符串的拼接、比较、赋值、下标访问等操作，并使用友元函数来实现字符串的输入输出功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值