C++运算符重载

最新推荐文章于 2020-11-23 11:13:53 发布

memewry

最新推荐文章于 2020-11-23 11:13:53 发布

阅读量1k

点赞数

分类专栏： 4.C/C++ 文章标签： c++ c class 编译器网络

本文链接：https://blog.csdn.net/memewry/article/details/7832863

版权

4.C/C++ 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

运算符重载是C++编译时多态的一种形式，可使代码简洁直观具有可读性，搜罗了一些资料，将C++中的运算符重载技术简单总结如下

1、运算符重载是对已有运算符赋予多重含义，使同一个运算符作用域不同数据类型的数据导致不同行为的发生，比如：

int i;
 int i1=10,i2=10;
 i=i1+i2;
 std::cout<<"i1+i2="<<i<<std::endl;
 
 double d;
 double d1=20,d2=20;
 d=d1+d2;
 std::cout<<"d1+d2="<<d<<std::endl;

在这里”+”即完成两个整形数的加法运算，又完成了双精度的加法运算。为什么同一个运算符"+"可以用于完成不同类型的数据的加法运算？这是因为C++针对预定义基本数据类型已经对"+"运算符做了适当的重载。在编译程序编译不同类型数据的加法表达式时，会自动调用相应类型的加法运算符重载函数。但是C++中所提供的预定义的基本数据类型毕竟是有限的，在解决一些实际的问题时，往往需要用户自定义数据类型。比如复数。

class Complex //复数类
{
 public:
 double real;//实数
 double imag;//虚数
 Complex(double real=0,double imag=0)
 {
 this->real=real;
 this->imag=imag;
 }
}

如果我们生成两个负数，并直接用”+””-””*””/”进行运算，则编译器就会报错。这是因为这是因为Complex类类型不是预定义类型，系统没用对该类型的数据进行加法运算符函数的重载。C++就为运算符重载提供了一种方法，即运算符重载函数。其函数名字规定为operator后紧跟重载运算符。比如：operator+(),operator*()等。

2、下面是一个负数运算重载的四则运算符的例子。首先定义一个负数类，然后完成运算符的重载：

#include <iostream>
#include <typeinfo>
using namespace std;

class fushu
{
public:
	fushu() {shibu = xubu = 0;}
	fushu(double r,double i)
	{
		shibu = r;
		xubu = i;
	}
	fushu operator +(const fushu &c);
	fushu operator -(const fushu &c);
	fushu operator *(const fushu &c);
	fushu operator /(const fushu &c);

	friend void print(const fushu &c);
private:
	double shibu,xubu;
};

inline fushu fushu :: operator +(const fushu &c)
{
	return fushu(shibu+c.shibu,xubu+c.xubu);

}
inline fushu fushu :: operator -(const fushu &c)
{
	return fushu(shibu-c.shibu,xubu-c.xubu);

}
inline fushu fushu :: operator *(const fushu &c)
{
	return fushu(shibu*c.shibu-xubu*c.xubu,shibu*c.xubu+xubu*c.shibu);

}
inline fushu fushu :: operator /(const fushu &c)
{
	return fushu((shibu*c.shibu+xubu+c.xubu),(xubu*c.shibu-shibu*c.xubu));

}

void print(const fushu &c)
{
	if(c.xubu<0)
		cout<<c.shibu<<c.xubu<<'i';
	else cout<<c.shibu<<'+'<<c.xubu<<'i';
}

int main()
{
	fushu c1(1.0,2.0),c2(3.0,4.0),c3;
	c3= c1+c2;
	cout<<"\n c1+c2=";
	print(c3);

	c3= c1-c2;
	cout<<"\n c1-c2=";
	print(c3);

	c3= c1*c2;
	cout<<"\n c1*c2=";
	print(c3);

	c3= c1/c2;
	cout<<"\n c1/c2=";
	print(c3);
	return 0;
}

运行结果如下：

其实在上面的调用中也可以用

c3=c1.fushu::operator+(c2);

cout<<"\nc1+c2=";

print(c3);

来代替，都是一样的、只是c3=c1+c2更符合我们的表达习惯。

3、实际上运算符重载一般采用两种形式：

成员函数形式和友元函数形式。这两种形式都可以访问类中的私有成员。

(1)运算符重载函数作为类的友元函数的形式：

class 类名

{

friend返回类型operator运算符(形参表);

}

　　类外定义格式：

　　返回类型operator运算符(参数表)

{

　　　　函数体

}

友元函数重载双目运算符(有两个操作数，通常在运算符的左右两则)，参数表中的个数为两个。若是重载单目运算符(只有一个操作数)，则参数表中只有一参数。

运算符重载函数可以返回任何类型，甚至是void，但通常返回类型都与它所操作的类类型一样，这样可以使运算符使用在复杂的表达式中。赋值运算符=、下标运算符[]、函数调用运算符()等是不能被定义为友元运算符重载函数。同一个运算符可以定义多个运算符重载函数来进行不同的操作。

(2)运算符重载函数作为类的成员函数的形式：

class 类名

{

　　　　返回类型operator 运算符(形参表);

}

　　　类外定义格式：

　　返回类型类名::operator 运算符(形参表)

{

　　　　函数体;

}

对于成员函数重载运算符而言，双目运算符的参数表中仅有一个参数，而单目则无参数。同样的是重载，为什么和友元函数在参数的个数上会有所区别的。原因在于友元函数，没有this指针。

例如：对于双目运算符而言，运算符重载函数的形参中仅为一个参数，它作为运算符的右操作数(如c对象)，而当前对象作为左操作数，它是通过this指针隐含传递给成员运算符重载函数的。

4、总结：

1、绝大部分运算符都能够重载，除了以下几个

. .* :: :?

2、运算符重载也可以定义成全局函数，不属于任何类，只要类中的数据成员是public权限，类对象就可以调用他。

3、定义一个运算符重载就像定义一个函数，只是该函数的名字是operator@，这里@代表运算符。函数参数表中的参数个数取决于以下因素：

运算符定义为全局函数或友元函数，则单目运算符是一个参数，二目运算符是两个参数，如果运算符第一位非静态的成员函数，则单目运算符没有参数，二目运算符是一个参数。

在程序中对运算符“++”进行了重载,使它能用于Time类对象｡“++”和“--”运算符有两种使用方式,前置自增运算符和后置自增运算符,它们的作用是不一样的,在重载时怎样区别这二者呢?

看下面一个例子：

#include<iostream>
using namespace std;

class a
{
private:
	int val;
public:
	a(){val=0;}
	void operator++(){val +=1;}
	void operator++(int){val +=2;} 

	friend void print(const a &c);
};
void print(const a &c)
{
	cout<<c.val<<endl;
}
int main()
{
	a obj;
	print(obj);
	obj++;
	print(obj);
	++obj;
	print(obj);
	return 0;
}

针对“++”和“--”这一特点,C++约定: 在自增(自减)运算符重载函数中,增加一个int型形参,就是后置自增(自减)运算符函数｡

5、最后借用网络上的一个例子来结束本文，有一个Time类,包含数据成员minute(分)和sec(秒),模拟秒表,每次走一秒,满60秒进一分钟,此时秒又从0开始算｡要求输出分和秒的值｡。

代码如下：

#include <iostream>
using namespace std;
class Time
{
   public:
   Time( ){minute=0;sec=0;}  //默认构造函数
   Time(int m,int s):minute(m),sec(s){ } //构造函数重载
   Time operator++( ); //声明运算符重载函数
   void display( ){cout<<minute<<":"<<sec<<endl;} //定义输出时间函数
   private:
   int minute;
   int sec;
};
Time Time::operator++( )  //定义运算符重载函数
{
   if(++sec>=60)
   {
      sec-=60; //满60秒进1分钟
      ++minute;
   }
   return *this;  //返回当前对象值
}
int main( )
{
   Time time1(34,0);
   for (int i=0;i<61;i++)
   {
      ++time1;
      time1.display( );
   }
   return 0;
}

参考文献：http://see.xidian.edu.cn/cpp/biancheng/view/219.html

http://www.cnblogs.com/CaiNiaoZJ/archive/2011/08/12/2136598.html

memewry

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++运算符重载

运算符重载是C++编译时多态的一种形式，可使代码简洁直观具有可读性，搜罗了一些资料，将C++中的运算符重载技术简单总结如下1、运算符重载是对已有运算符赋予多重含义，使同一个运算符作用域不同数据类型的数据导致不同行为的发生，比如：int i; int i1=10,i2=10; i=i1+i2; std::cout<<"i1+i2="<<i<<std::endl; double d
复制链接

扫一扫