C++ C5 -运算符重载-单目（前置，后置）-双目-实现字符串类各种运算符重载

最新推荐文章于 2023-05-08 17:15:12 发布
最新推荐文章于 2023-05-08 17:15:12 发布
阅读量677 收藏 8
点赞数 4
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cy_612/article/details/113184842
版权

运算符重载

	运算符：单目/双目/三目
	注意：
	1.不能改变优先级，结合性
	2.不能改变所需要的操作数
	3.不能创建新的运算符

单目运算符

	单目运算符：++ --（分为前置和后置）

前置运算符：

			运算符重载本质是一个成员函数；
			成员函数方法：
						<返回值> operator<运算符>（<参数列表>)
						CPoint operator ++( );
			友元函数
						friend <返回值> operator <运算符>（<参数列表>）
						friend CPoint operator++(CPoint &c)

class CPoint
{
private:
	int x;
	int y;
public:
	CPoint(int x,int y)
	{
		this->x = x;
		this->y = y;
	}
	~CPoint(){}
	void show()
	{
		cout << "(" << x << "," << y << ")" << endl;
	}
	//CPoint operator++();  //成员函数的实现
	friend CPoint operator++(CPoint &c);
};

/*CPoint CPoint::operator++()
{
	this->x++;
	this->y++;
	return *this;
}*/

CPoint operator++(CPoint &c)
{
	c.x++;
	c.y++;
	return c;
}

int main()
{
	CPoint c1(3,4);
	c1.show();
	(++c1).show();

	system("pause");
	return 0;
}

后置运算符
成员函数：
<返回值> operator <运算符>（<参数列表>）
CPoint operator++(int); (this指针)
int没有任何实际意义，仅仅是后置单目运算符的标志
友元函数：
friend <返回值> operator <运算符>（<参数列表>）
friend CPoint operator++(CPoint &c,int)
1.参数列表 需要加一个int作为标识符
2.实现：先用一个中转对象保存原数值

#include <iostream>
using namespace std;

class CPoint
{
private:
	int x;
	int y;
public:
	CPoint(int x,int y)
	{
		this->x = x;
		this->y = y;
	}
	~CPoint(){}
	void show()
	{
		cout << "(" << x << "," << y << ")" << endl;
	}
	CPoint operator++(int);   //成员函数实现
	friend CPoint operator++(CPoint &c,int);	
};

CPoint CPoint::operator++(int)
{
	CPoint temp = *this;     //后置++ 需要返回最初的值
	this->x++;
	this->y++;
	return temp;
}
CPoint operator++(CPoint &c,int)
{
	CPoint c1 = c;    //c1保存最初的值
	c.x++;
	c.y++;
	return c1;

}


int main()
{
	CPoint c1(3,4);
	c1.show();   //(3,4)
	(c1++).show(); // (3,4)
	c1.show();   //(4,5)

	system("pause");
	return 0;

}

双目运算符

+ - * /
成员函数：
<返回值> operator <运算符>（<参数列表>）
Complex operator+(Complex c2);
参数列表中参数表示右操作数,左操作数用this指针操作
友元函数：
friend Complex operator+(Complex c1,Complex c2)
用成员函数时候 总会有一个this指针指向其中一个操作数；
用友元函数时候 没有this指针，需要通过参数列表将所有的操作数传进去
左右移 运算符
friend ostream& operator<<(ostream& os,Complex c);
赋值运算符
赋值运算符 =
一般情况下，系统为每一个类都生成一个默认的赋值运算符
浅拷贝的问题出在默认构造函数 解决方法：深拷贝（自己写拷贝构造）
指针悬挂问题出在默认赋值运算符 解决方法：自己重载赋值运算符
注意点：
1不可以用友元重载
2不可以被继承
3不可以声明为虚函数
成员变量有指针/有赋值操作，需要自己重载赋值运算符
数组下标运算符 []
不能使用友元重载
//函数返回值当左值，需要返回一个引用
//应该返回一个引用(元素本身) 而不是一个值

int& myArray::operator[](int i)
{
	if(i>m_length)
	{
		cout << "数组下标越界" << endl;
	}
	return m_space[i];
}

实现字符串类

myarray.h

#ifndef MYARRAY_H_INCLUDED
#define MYARRAY_H_INCLUDED
#include <iostream>
#include <cstring>
using namespace std;
class MyString
{
public:
    MyString();
    MyString(const int number);
    MyString(const char *ptr);
    MyString(const MyString &str);
    ~MyString();

    MyString& operator =(const MyString &str);
    MyString& operator =(const char *p);

    char& operator [](const int index);

    bool operator ==(const MyString& str)const;
    bool operator ==(const char *p) const;

    bool operator !=(const MyString& str)const;
    bool operator !=(const char *p) const;

    bool operator >(const MyString& str)const;
    bool operator >(const char *p) const;

    bool operator <(const MyString& str)const;
    bool operator <(const char *p) const;

    MyString operator +(const MyString &str)const;

    friend ostream& operator <<(ostream &out, const MyString &str);
    friend istream& operator >>(istream &in, const MyString &str);
private:
    int len;
    char *pstr;
};
#endif // MYARRAY_H_INCLUDED

myarray.cpp

#include "myarray.h"
MyString::MyString()
{
    len=0;
    pstr = new char[1];
    strcpy(pstr,"");

}
MyString::MyString(const int number)
{
    len = number;
    pstr = new char[len+1];
    strcpy(pstr,"");
}
MyString::MyString(const char *ptr)
{
    len = strlen(ptr);
    pstr = new char[len+1];
    strcpy(pstr,ptr);
}
MyString::MyString(const MyString &str)
{
    len = str.len;
    pstr = new char[len+1];
    strcpy(pstr,str.pstr);

}
MyString::~MyString()
{
    delete[] pstr;
    pstr=NULL;
    len=0;
}
MyString& MyString::operator =(const MyString &str)
{
    len = str.len;
    if(pstr!=NULL)
        delete[] pstr;
    pstr = NULL;
    pstr = new char[len+1];
    strcpy(pstr,str.pstr);
    return *this;
}

MyString& MyString::operator =(const char *p)
{
    cout<<"1NULL"<<endl;
    if(p==NULL)
    {
        cout<<strlen(p)<<endl;
        len =0;
        pstr = new char[1];
        strcpy(pstr,"");
        return *this;
    }
    cout<<"3NULL"<<endl;
    len = strlen(p);
    if(pstr!=NULL)
        delete[] pstr;
    pstr = NULL;
    pstr = new char[len+1];
    strcpy(pstr,p);
    return *this;
}
char& MyString::operator [](const int index)
{
    return *(pstr+index);
}

bool MyString::operator ==(const MyString& str)const
{
    if(strcmp(pstr,str.pstr)==0)
        return true;
    else
        return false;
}

bool MyString::operator ==(const char *p) const
{
    if(p==NULL)
    {
        if(len==0)
            return true;
        else
            return false;
    }
    if(strcmp(pstr,p)==0)
        return true;
    else
        return false;
}

bool MyString::operator !=(const MyString& str)const
{
    if(strcmp(pstr,str.pstr)!=0)
        return true;
    else
        return false;
}

bool MyString::operator !=(const char* p)const
{
    if(p==NULL)
    {
        if(len==0)
            return true;
        else
            return false;
    }
    if(strcmp(pstr,p)!=0)
        return true;
    else
        return false;
}

bool MyString::operator >(const MyString& str)const
{
    if(strcmp(pstr,str.pstr)>0)
        return true;
    else
        return false;
}

bool MyString::operator >(const char* p)const
{
    if(strcmp(pstr,p)>0)
        return true;
    else
        return false;
}

bool MyString::operator <(const MyString& str)const
{
    if(strcmp(pstr,str.pstr)<0)
        return true;
    else
        return false;
}

bool MyString::operator <(const char* p)const
{
    if(strcmp(pstr,p)<0)
        return true;
    else
        return false;
}

MyString MyString::operator +(const MyString &str)const
{
    MyString temp;
    temp.len=strlen(str.pstr)+len;
    temp.pstr = new char[len+1];
    strcpy(temp.pstr,pstr);
    strcat(temp.pstr,str.pstr);
    return temp;
}

ostream& operator <<(ostream &out, const MyString &str)
{
    out << str.pstr;
    return out;
}

istream& operator>>(istream& in, const MyString& str)
{
    in >> str.pstr;
    return in;
}

main.cpp

int main1()
{
    MyString s1;
    MyString s2("s2");
    MyString s2_2 = NULL;
    MyString s3 = s2;
 
    MyString s4 = "s42323233";
    s4 = s2;
    s4 = "headad";
 
    cout << s4[2] << endl;
 
    cout << s4 << endl;
 
    return 0;
}
 
int main2()
{
    MyString s1;
    MyString s2("s2");
    MyString s3("s223123");
    if (s2 == NULL)
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    }
 
    if (s2 == s3)
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    } 
    return 0;
}
 
int main3()
{
    MyString s1;
    MyString s2("s2");
    MyString s3("s3");
 
    if (s3 < "bbbb")
    {
        cout << "s3 < bbbb" << endl;
    }
    else
    {
        cout << "s3 > bbbb" << endl;
    }
 
    if (s3 > s2 )
    {
        cout << "s3 > s2" << endl;
    }
    else
    {
        cout << "s3 < s2" << endl;
    }
 
    return 0;
}
 
int main()
{
    MyString s1(128);
    cin >> s1;
 
    cout << s1 << endl;
 
    return 0;
}
陈年梦，越人心
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
C++实验报告实验七-运算符重载
最新发布
03-14
编写程序熟悉重载单目和双目运算符的方法； （3）.编写程序熟悉流插入和提取运算符的重载； 二、实验要求 1、创建一个二维坐标点point的类别，该类别能够存放一个二维坐标点（x，y）。重载运算符“++”，使之能用于...
运算符前置++和后置++重载为时钟类的成员函数
计算机札记大全
08-25 2280
源程序： #include&lt;iostream.h&gt; class Clock //时钟类声明 { public: //外部接口 Clock(int NewH=0, int NewM=0, int NewS=0); void ShowTime(); Clock&amp; operat...
单目运算符重载
加载中...
04-06 1161
前置单目运算符重载规则：设U为前置单目运算符，oprd为类A的对象，则U应被重载为A类的成员函数方式：oprd.operator U()后置单目运算符重载规则：后置单目运算只有两个："++"和"--"很显然"++"和"--"也可以作为前置单目运算符，这样oprd.operator ++()就会歧义，到底是重置前置的"++"还是后置的"++"呢？解决方法：强行传一个没有意义的int参数只是为
重载单目运算符（以++为例，前置和后置）
weixin_62802660的博客
04-28 882
有一个time 类，包括数据成员minute ,sec模拟秒表，每次走一秒，满60秒进一分钟，此时秒从0起算 #include <iostream> using namespace std; class Time { private ://私有数据成员 int sec;//秒 int minute;//分 public://公有数据 Time () { minute=0; sec=0; }//默认构造函数初...
c++运算符重载汇总,类成员和全局运算符重载,单目前置后置,cout＜＜,cin＞＞,仿函数,函数对象教程
小手琴师的博客
10-14 723
目录运算符重载的格式全局 双目运算符 代码示例类里面的成员函数重载运算符类成员双目运算符+,+=,==,!= 的实现类成员函数的无参数的运算符重载分为操作符前置后后置,例如++i,i++单目运算符前置,就是操作符在前面,例如 ++i,--i单目运算符后置,就是运算符在后面,例如i++,i--,有固定的格式, 在运算符()后面加(int)重载输入和输出 << >>重载赋值运算符=,在子类中要调用父类的=赋值运算符重载仿函数 ,函数对象,通过重载()实现不能重载的运算符 运算符重载的格
C语言学习笔记(二)
03-21 250
C语言学习笔记c语言运算符1赋值运算符2算术运算符3逻辑运算符4关系运算符5三目运算符6位运算符7单目运算符 c语言运算符 c语言常用的用算符包括赋值运算符，算术运算符，逻辑运算符，关系运算符。 1赋值运算符 赋值运算符的原型： 变量标识符 = 变量初始化值； 2算术运算符 包括 +，-，*，/ 3逻辑运算符 包括&&，||，！ 4关系运算符 包括> , < ,&g...
C++作业实验-运算符重载
06-20
主要是C++中，运算符重载的编写的实验，环境VS2010，内容很基本，与类相关
C++实验11--运算符重载.html
05-25
C++实验11--运算符重载.html
关于为什么重载=要使用引用
何解然_K|user
03-19 1399
先那我写的作为一个例子来说明吧 person& operator=(person& p)//使用引用 { if (m_age != NULL) { delete m_age; m_age = NULL; } m_age = new int(*p.m_age); return *this; } 在VS下单步调试会发现，如果不使用引用执行到...
单目运算符重载、双目运算符重载为成员（或非成员）函数
weixin_48657700的博客
11-11 2883
1.单目运算符只能重载为类的成员函数 Clock& operator ++ ();//前置单目运算符重载 没有形参，返回的是clock类的引用，是一个左值。 Clock operator ++ (int); //后置单目运算符重载 后置++要有一个int类型的形参，返回的是一个clock类的旧值，是一个右值 2.双目运算符 重载为成员函数时： Complex operator + (const Complex &c2) const; +两边有一个空格，只有一个形参。 重载为非成员函数时：
196-C++运算符的重载(C++ string类的实现 & String迭代器的实现）
Edward_LF的博客
05-12 929
1、C++ string类的实现 1.1、“+”运算符重载函数 “+”运算符重载函数 较 其他函数要复杂一点！ 这个写法的效率不好。 ptmp指向new出来的内存，然后字符串拷贝，连接，当做参数传入tmp对象，tmp构造的时候又会根据传进来的指针进行判空，然后开辟内存，进行字符串拷贝，然后把这个ptmp指针delete掉，tmp是局部对象，return tmp，析构的时候又要把刚才构造时new出来的空间delete掉，2次new2次delete，太麻烦了。 我们应该这么做： String operat
C++ 实现字符串类（重载运算符）
weixin_43731641的博客
07-07 2456
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
C++中类的运算符重载教程（一），内附完整代码与解析
qq_51004011的博客
06-24 1799
我们在实现完成类的两对象+重载函数后，再直接进行两个对象相加时，+运算符会自动匹配operator+函数，然后p1与p2分别与该函数的第一个，第二个参数类型相匹配，最后成功调用该函数。
c++重载运算符和重载函数（图、文、代码）
xuelang532777032的博客
05-08 120
下面代码看着眼熟是不是?console.log正是web前端的浏览器打印！告诉类，有这个减号时要做什么操作。然后把函数里处理完的对象返回给。博主理解就是，函数名一样，但是形参不一样！形参的 个数、数量不一样！2、然后计算出他们各自的。1、我赋值给两个对象。
前置后置单目运算符重载函数返回值用法
ShenHang_的博客
05-01 837
转载自：https://www.cnblogs.com/zhanjxcom/p/4418201.html Clock& Clock::operator ++() //前置单目运算符重载函数 { Second++; if(Second>=60) { Second=Second-60; Minute++; if(Minute>=60) { Minute=Minute-60; Hou...
C++面向对象基础&运算符重载思维导图
dwc001666的博客
01-10 313
类：类是对同一类对象的抽象总结，是一个概念。 对象：按照类的规定创建的实体。 程序员就是面向对象编程世界中的“上帝”，因此需要先写类的代码，才能按照这段代码创建对应的对象。参考类来创建对象的过程被称为“实例化”。因此，对象无法脱离对应的类存在。
C++详细的各种运算符重载
m0_49586319的博客
02-02 130
C++对＋，自加++，赋值=，cout等运算符的重载以及详细使用。
【C++语法地图】+ 运算符重载
M1nor的博客
12-23 485
概念：对已有的运算重新进行定义，赋予其另一种功能，用于适应不同的数据类型 加号运算符重载 重载意义：可以实现两个自定义数据类型的相加运算 #include<iostream> using namespace std; int main(){ int a = 10; int b = 20; int c = a + b; } 如上图，对于内置数据类型，编译器本来就知道如何运算，但是对于非内置的数据类型混合运算，就需要人为定义运算法则 成员函数重载+运算符 class
c++电子时钟，重载+运算符和-运算符
05-15
下面是一个基本的 C++ 电子时钟实现，其中重载了 + 和 - 运算符： ```c++ #include using namespace std; class Clock { private: int hour, minute, second; public: Clock(int h = 0, int m = 0, int s = 0)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值