c++中运算符重载是我们经常使用，所以必然也很重要。那么重载运算符的作用好处是什么？它允许你为类的用户提供一个直觉的接口。运算符重载允许C/C++的运算符在用户定义类型(类)上拥有一个用户定义的意义。例如加+，减，乘，除等。当用户订义了类的对象时，两个对象之间是不能进行这些操作的，比如number类的对象a+b，这样的语句如果没有重载+运算符就会出错。但C++允许用户把这些运算符添加到自已的类中以方便类对象之间的运算就像内置类型的运算一样方便，比如对象a+b 这样就很明白更容易懂，当然也可以在类中定义一个对象间相加的函数，比如a.add(b)调用函数add()以实现两个对象a 和b 相加，但是这条语句没有比a+b 更容易让人理解。
1. 哪些运算符可以用作重载？
几乎所有的运算符都可用作重载。具体包含：
算术运算符：+,-,*,/,%,++,--;
位操作运算符：&,|,~,^,＜＜,＞＞
逻辑运算符：!,&&,||;
比较运算符：＜,＞,＞=,＜=,==,!=;
赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*
但是下列运算符不允许重载：
.,.*,::,?:
2. 重载运算符有哪些限制？
a）不能改变运算符操作数的个数；
b)·不能改变运算符原有的优先级；
c)不能改变运算符原有的结合性；
d)不能改变运算符原有的语法结构；
3. 运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。
(1). 重载为类的成员函数
学过数学的都知道复数由实部和虚部构造
这里的实例就是是关于给复数运算重载复数的四则运算符的例子：
Complex.h文件
#ifndef COMPLEX_H
#define COMPLEX_H
class Complex{
public:
Complex();
Complex(double r,double i);
Complex operator +(const Complex &p);
Complex operator -(const Complex &p);
Complex operator *(const Complex &p);
Complex operator /(const Complex &p);
void show(const Complex &p);
~Complex();
private:
double real,imag;
};
#endif
这里是comp.cpp文件
#include<iostream>
using namespace std;
#include"complex.h"
Complex::Complex()
{
real=0;
imag=0;
}
Complex::Complex(double real,double imag)
{
this->real=real;
this->imag=imag;
}
Complex Complex::operator +(const Complex &p)
{
return Complex(this->real+p.real,this->imag+p.imag);
}
Complex Complex::operator -(const Complex &p)
{
return Complex(this->real-p.real,this->imag+p.imag);
}
Complex Complex::operator *(const Complex &p)
{
return Complex(this->real*p.real,this->imag*p.imag);
}
Complex Complex::operator /(const Complex &p)
{
return Complex((this->real*p.real+this->imag+p.imag) / (p.real*p.real+p.imag*p.imag),
(this->imag*p.real-this->real*p.imag) / (p.real*p.real+p.imag*p.imag));
}
void Complex::show(const Complex &p)
{
if(p.imag>0)
{
cout<<p.real<<"+"<<p.imag<<"i"<<endl;
}
else
cout<<p.real<<p.imag<<"i"<<endl;
}
Complex::~Complex()
{
}
main.cpp文件
#include<iostream>
using namespace std;
#include"Complex.h"
int main()
{
Complex cp1(8.0,4.0),cp2(12.0,-2.0),cp3;
cp3=cp1+cp2;
cout<<"cp1+cp2=";
cp3.show(cp3);
cp3=cp1-cp2;
cout<<"cp1-cp2=";
cp3.show(cp3);
cp3=cp1*cp2;
cout<<"cp1*cp2=";
cp3.show(cp3);
cp3=cp1/cp2;
cout<<"cp1/cp2=";
cp3.show(cp3);
return 0;
}
程序结果为：
cp1+cp2=20+2i
cp1-cp2=-4+2i
cp1*cp2=96-8i
cp1/cp2=0.662162+0.432432i
程序中的operator是定义运算符重载函数的关键字 其中main.cpp文件中表达式cp1+cp2 编译程序将给解释为： cp1.operator+(cp2) 其中，cp1和cp2是complex类的对象。operator+()是运算+的重载函数。 该运算符重载函数仅有一个参数cp2。
可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。
这里解释一下什么是单目运算符和双目运算符以及三目运算符：
1.单目就是这个运算符只对一个变量进行操作
代表符号：!(逻辑非) ~（按位取反）++（自增）--（自减）如：--、++
2.双目就是这个运算符对两个变量进行操作. 如：+、-、*、/、= 等。
3.三目就是这个运算符对三个变量进行操作
代表符号： ?:(条件运算符)（需要三个操作数）
4.下面介绍一下重载为友元函数
当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。
实例还是上面的例子：
Complex.h文件
#ifndef COMPLEX_H
#define COMPLEX_H
class Complex{
public:
Complex();
Complex(double r,double i);
Complex operator +(const Complex &p,const Complex &p1);
Complex operator -(const Complex &p,const Complex &p1);
Complex operator *(const Complex &p,const Complex &p1);
Complex operator /(const Complex &p,const Complex &p1);
void show(const Complex &p);
~Complex();
private:
double real,imag;
};
#endif
这里是comp.cpp文件
#include<iostream>
using namespace std;
#include"complex.h"
Complex::Complex()
{
real=0;
imag=0;
}
Complex::Complex(double real,double imag)
{
this->real=real;
this->imag=imag;
}
Complex Complex::operator +(const Complex &p,const Complex &p1)
{
return Complex(p.real+p1.real,p.imag+p1.imag);
}
Complex Complex::operator -(const Complex &p,const Complex &p1)
{
return Complex(p.real-p1.real,p.imag+p1.imag);
}
Complex Complex::operator *(const Complex &p,const Complex &p1)
{
return Complex(p.real*p1.real,p.imag*p1.imag);
}
Complex Complex::operator /(const Complex &p,const Complex &p1)
{
return Complex((p.real*p1.real+p.imag+p1.imag) / (p1.real*p1.real+p1.imag*p1.imag),
(p.imag*p1.real-p.real*p1.imag) / (p1.real*p1.real+p1.imag*p1.imag));
}
void Complex::show(const Complex &p)
{
if(p.imag>0)
{
cout<<p.real<<"+"<<p.imag<<"i"<<endl;
}
else
cout<<p.real<<p.imag<<"i"<<endl;
}
Complex::~Complex()
{
}
main.cpp文件
#include<iostream>
using namespace std;
#include"Complex.h"
int main()
{
Complex cp1(8.0,4.0),cp2(12.0,-2.0),cp3;
cp3=cp1+cp2;
cout<<"cp1+cp2=";
cp3.show(cp3);
cp3=cp1-cp2;
cout<<"cp1-cp2=";
cp3.show(cp3);
cp3=cp1*cp2;
cout<<"cp1*cp2=";
cp3.show(cp3);
cp3=cp1/cp2;
cout<<"cp1/cp2=";
cp3.show(cp3);
return 0;
}
程序运行的结果和上面的一样:
cp1+cp2=20+2i
cp1-cp2=-4+2i
cp1*cp2=96-8i
cp1/cp2=0.662162+0.432432i
重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。所以，程序中出现的cp1+cp2 编译程序解释为operator+(cp1, cp2)
上面两种重载形式的比较 ：有什么不同
一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
