C语言运算符的重载详解

2024-04-02 19:04:59 478人浏览八月长安

摘要

目录运算符重载的规则 1. 运算符重载为成员函数2. 运算符重载为非成员函数

运算符重载的规则

思考：用“+”、“-”能够实现复数的加减运算吗？
实现复数加减运算的方法：

——重载“+”、“-”运算符

运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。
c++ 几乎可以重载全部的运算符，而且只能够重载C++中已经有的。

不能重载的运算符：“.”、“.*”、“::”、“?:”

重载之后运算符的优先级和结合性都不会改变。
运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。例如：

使复数类的对象可以用“+”运算符实现加法；

使时钟类对象可以用“++”运算符实现时间增加1秒。

重载为类的非静态成员函数；
重载为非成员函数。

1. 运算符重载为成员函数

重载为类成员的运算符函数定义形式：

函数类型 operator 运算符（形参）

{

......

}

参数个数=原操作数个数-1 （后置++、--除外）

双目运算符重载规则

如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2) 。

例1 复数类加减法运算重载为成员函数

要求：将+、-运算重载为复数类的成员函数。

规则：实部和虚部分别相加减。

操作数：两个操作数都是复数类的对象。

#include<iOStream>
using namespace std;
//定义复数类
class Complex
{ 
	public:
		Complex(double x=0.0, double y=0.0);  //构造函数
		Complex(const Complex &c);  //复制构造函数 
		~Complex();  //析构函数
		void display() const;  //复数打印函数
		Complex operator +(const Complex &c) const;  //加法运算符重载
		Complex operator -(const Complex &c) const;  //减法运算符重载 
	private:
		double real;  //实部
		double imag;  //虚部 
}; 
Complex::Complex(double x, double y): real(x), imag(y){}
Complex::~Complex(){}
Complex::Complex(const Complex &c): real(c.real), imag(c.imag){}
void Complex::display() const
{
	cout<<"("<<real<<", "<<imag<<")"<<endl;	
}
Complex Complex::operator +(const Complex &c) const
{
	Complex temp;
	temp.real = real + c.real;
	temp.imag = imag + c.imag;
	return temp;
	
	//return Complex(real+c.real, imag+c.imag); 
}
Complex Complex::operator -(const Complex &c) const
{
	Complex temp;
	temp.real = real - c.real;
	temp.imag = imag - c.imag;
	return temp;
}
int main()
{
	Complex c1(6.7, 4.4);
	Complex c2(3.2, 1.7);
	cout<<"c1 = ";
	c1.display();
	cout<<endl;
	cout<<"c2 = ";
	c2.display();
	cout<<endl;
	Complex c3, c4;
	c3 = c1 + c2;
	c4 = c1 - c2;
	cout<<"c1 + c2 = ";
	c3.display();
	cout<<endl;
	cout<<"c1 - c2 = ";
	c4.display();
	cout<<endl;
	return 0;
}

运行结果：

c1 = (6.7, 4.4)
c2 = (3.2, 1.7)
c1 + c2 = (9.9, 6.1)
c1 - c2 = (3.5, 2.7)

前置单目运算符++和--重载规则

如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。
经重载后，表达式 U oprd 相当于 oprd.operator U()。

后置单目运算符++和--重载规则

如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)。

例2 重载前置++和后置++为时钟类成员函数

前置单目运算符，重载函数没有形参。

后置++运算符，重载函数需要有一个int形参。

操作数是时钟类的对象。

实现时间增加1秒钟。

#include<iostream>
using namespace std;
class Clock
{
	public:
		Clock(int hour=0, int minute=0, int second=0);
		~Clock();
		void showTime() const;
		Clock& operator ++();  //前置单目运算符重载
		Clock operator ++(int);  //后置单目运算符重载 
	private:
		int hour;
		int minute;
		int second;
};
Clock::Clock(int hour, int minute, int second)
{
	if(0<=hour && hour<24 && 0<=minute && minute<60 && 0<=second && second<60)
	{
		this->hour = hour;
		this->minute = minute;
		this->second = second;
	}
	else
	{
		cout<<"Time error!"<<endl;
	}
}
Clock::~Clock(){}
void Clock::showTime() const
{
	cout<<hour<<":"<<minute<<":"<<second<<endl;
}
Clock& Clock::operator ++()  //函数返回值是对象的引用是为了更高效（减少临时对象的生成）
{
	second++;
	if(second >= 60)
	{
		second %= 60;
		minute++;
		if(minute >= 60)
		{
			minute %= 60;
			hour = (hour + 1) % 24;
		}
	}
	return *this;
}
Clock Clock::operator ++(int)  //注意形参表中的整型参数
{
	Clock old = *this;
	++(*this);   //调用前置“++”运算符
	
	return old; 
} 
int main()
{
	Clock myClock(23, 59, 59); 
 	cout << "First time output: "; 
 	myClock.showTime(); 
 	cout << "Show myClock++: "; 
 	(myClock++).showTime(); 
 	cout << "Show ++myClock: "; 
 	(++myClock).showTime();
	return 0;
}

运行结果：

First time output: 23:59:59
Show myClock++: 23:59:59
Show ++myClock: 0:0:1

2. 运算符重载为非成员函数

有些运算符不能重载为成员函数，例如二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象。

运算符重载为非成员函数的规则

函数的形参代表依自左至右次序排列的各操作数。
重载为非成员函数时：

参数个数=原操作数个数（后置++、--除外）。

至少应该有一个自定义类型的参数。
后置单目运算符++和--的重载函数，形参列表中要增加一个int，但不必写形参名。
如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。
双目运算符B重载后，表达式oprd1 B oprd2等同于operator B(oprd1,oprd2)。
前置单目运算符B重载后，表达式B oprd等同于operator B(oprd)。
后置单目运算符++和--重载后，表达式oprd B等同于operator B(oprd,0)。

例3 重载 Complex 的加减法和“<<”运算符为非成员函数

将+、‐（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用（使用常引用，既保证程序执行的高效率，又保护数据不被随意篡改）。
将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：

cout << a << b;

该输出调用的是：

operator << (operator << (cout, a), b);

#include<iostream>
using namespace std;
class Complex
{
	public:
		Complex(double x=0.0, double y=0.0);
		~Complex();
		friend Complex operator +(const Complex &c1, const Complex &c2);  //声明为类的友元
		friend Complex operator -(const Complex &c1, const Complex &c2);
		friend ostream& operator <<(ostream &out, const Complex &c);
	private:
		double real;
		double imag;
};
Complex::Complex(double x, double y): real(x), imag(y){}
Complex::~Complex(){}
Complex operator +(const Complex &c1, const Complex &c2)
{
	Complex temp;
	temp.real = c1.real + c2.real;
	temp.imag = c1.imag + c2.imag; 
	return temp;
	
	//return Complex(c1.real+c2.real, c1.imag+c2.imag); 
} 
Complex operator -(const Complex &c1, const Complex &c2)
{
	return Complex(c1.real-c2.real, c1.imag-c2.imag);
}
ostream& operator <<(ostream& out, const Complex &c)
{
	out<<"("<<c.real<<", "<<c.imag<<")";
	return out;
}


int main()
{
	Complex c1(5, 4), c2(2, 10), c3; 
 	cout << "c1 = " << c1 << endl; 
 	cout << "c2 = " << c2 << endl; 
 	c3 = c1 - c2;   //使用重载运算符完成复数减法 
 	cout << "c3 = c1 - c2 = " << c3 << endl; 
 	c3 = c1 + c2;   //使用重载运算符完成复数加法 
 	cout << "c3 = c1 + c2 = " << c3 << endl;
	return 0;
}

运行结果：

c1 = (5, 4)
c2 = (2, 10)
c3 = c1 - c2 = (3, -6)
c3 = c1 + c2 = (7, 14)

类的友元函数重载插入运算符和重载提取运算符在调用时只需像平常cin >> xxx 或 cout << xxx即可，而类的成员函数重载插入运算符和重载提取运算符在调用时是要xxx >> cin 或 xxx << cout，刚好和平常的用法是相反的。而xxx >> cin相当于xxx.operator>>(cin)；xxx << cout相当于xxx.operator<<(cout)。

用引用&，减少对象拷贝，增加速度和效率。插入和提取运算符，操作的对象是ostream和istream。如果不加&的话，程序也是没问题的，可以运行。但是在每次调用<<操作的时候，都会产生一个新的临时的ostream对象。包括对“=”运算符的重载也是一样。“=”更能说明这个问题。一般来说是 xxx & opreator = (xxx a);就是因为我们希望对于a=b; 把b的值直接赋值给a就好了，用xxx &做返回类型，返回的是a的别名/引用，不会创建新的临时对象。如果没有&，那么会创建新的临时值返回，低效。重点就是对引用&的使用的理解。