运算符重载

运算符重载的概念

运算符重载就是对现有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

所谓重载，就是重新赋予新的含义。例如函数重载，就是对一个已有的函数赋予新的功能

C++语言本身就重载了很多运算符，例如<<是位运算中的左移运算符，但在输出操作又是与流对象cout配合是的流插入运算符，>>运算符也是

C++允许程序员重载大部分运算符，使运算符符合所在的上下文环境。虽然重载运算符的任务也可以通过显式的函数调用来完成，但是使用运算符重载往往使程序更清晰

运算符函数

本质上，运算符重载是函数的重载。重载运算符使具有特殊名称的函数，形式如下：

返回类型 operator 运算符号(形式参数列表) { 
    函数体 } 

operator后接需要重载的运算符，成为运算符函数

运算符函数的函数名就是“operator运算符号”

例：

讯享网class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数 real=r; imag=i; } private: double real; //实部 double imag; //虚部 }; 

将’+'用于复数类的加法运算，运算符函数原型可以是：

complex operator + (const complex &a,const complex &b); 

调用运算符函数的形式如下：

讯享网operator 运算符号(实参列表); 

例如：

complex c1(1,2),c2(3,4),c3; c = operator + (c1,c2); 

以上虽然是规范的运算符函数调用方法，但程序员更喜欢写成：c3 = c1 + c2;

重载运算符的规则

1. C++绝大部分的运算符可以重载，不能重载的运算符有：. .* :: ?: sizeof
2. 不能改变运算符的优先级，结合型和运算对象数目
3. 运算符重载函数不能使用默认参数
4. 重载运算符必须具有一个类对象（或类对象的引用）的参数，不能全部是C++的内置数据类型
5. 一般若运算结果作为左值则返回类型为引用类型；若运算结果要作为右值，则返回对象
6. 重载运算符的功能应该与原来的功能一致

运算符重载为类成员函数

将运算符重载为类的成员函数，一般形式为：

讯享网class 类名 { 
    //类体 ..... 返回类型 operator 运算符号(形式参数列表) { 
    函数体 } ..... }; 

或者：

class 类名 { 
    //类体 ..... 返回类型 operator 运算符号(形式参数列表); ..... }; 返回类型 类名::operator 运算符号(形式参数列表) { 
    函数体 } 

当运算符重载为成员函数时，运算符函数的形式参数的个数比运算符规定的运算对象个数要少一个

原因是类的非静态成员函数都有一个隐含的this指针，运算符函数可以用this指针隐式地访问类对象的成员，因此这个对象自身的数据可以直接访问，不需要放到形参列表中进行传递，少了的运算对象就是该对象本身

1.双目运算符重载为类的成员函数，形式如下：

讯享网

讯享网返回类型 类名::operator op(const 所属类型 &obj2) { 
    ..... //this指针对应obj1运算对象 } 

例：设计一个复数类，实现该类对象的加法和减肥运算

#include<iostream> #include<string> #include<cmath> #include<algorithm> #include<cstring> #include<cstdlib> using namespace std; class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数  real=r; imag=i; } complex operator + (complex &c2); //重载+运算符 complex operator - (complex &c2); //重载-运算符 void display() { 
    cout<<real<<"+"<<imag<<"i"<<endl; } private: double real; //实部 double imag; //虚部  }; complex complex::operator +(complex &c2) { 
    complex c; c.real = c2.real+real; c.imag = c2.imag+imag; return c; } complex complex::operator -(complex &c2) { 
    complex c; c.real = real-c2.real; c.imag = imag-c2.imag; return c; } int main() { 
    complex c1(1,2),c2(3,4),c3; c3=c2+c1; c3.display(); //输出4+6i  c3=c2-c1; c3.display(); //输出2+2i  return 0; } 

2.前置单目运算符重载为类的成员函数，形式如下：

讯享网返回类型 类名::operator op() { 
    ..... //this指针对应obj运算对象 } 

例：实现复数类的前置自增运算

#include<iostream> #include<string> #include<cmath> #include<algorithm> #include<cstring> #include<cstdlib> using namespace std; class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数  real=r; imag=i; } complex operator ++(); //重载前置++  void display() { 
    cout<<real<<"+"<<imag<<"i"<<endl; } private: double real; //实部 double imag; //虚部  }; complex complex::operator ++() { 
    complex a; real++; imag++; a.real=real; a.imag=imag; return a; } int main() { 
    complex c1(1,2),c2; c2 = ++c1; c1.display(); //输出2+3i c2.display(); //输出2+3i return 0; } 

3.后置单目运算符重载为类的成员函数，形式如下：

讯享网返回类型 类名::operator op(int) { 
    ...... //this指针对应obj运算对象 } 

例：实现复数类的后置自增运算

#include<iostream> #include<string> #include<cmath> #include<algorithm> #include<cstring> #include<cstdlib> using namespace std; class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数  real=r; imag=i; } complex operator ++(int); //重载后置++  void display() { 
    cout<<real<<"+"<<imag<<"i"<<endl; } private: double real; //实部 double imag; //虚部  }; complex complex::operator ++(int) { 
    complex a; a.real=real; a.imag=imag; real++; imag++; return a; } int main() { 
    complex c1(1,2),c2; c2 = c1++; c1.display(); //输出2+3i c2.display(); //输出1+2i return 0; } 

运算符重载为友元函数

当运算符重载为友元函数时，运算符函数的形式参数的个数和运算符规定的运算对象个数一致

形式如下：

讯享网class 类名 { 
    //类体 ..... //友元声明 friend 返回类型 operator 运算符号(形式参数列表); }; 返回类型 operator 运算符号(形式参数列表) { 
    函数体 } 

1.双目运算符重载为类的友元函数，形式如下：

返回类型 operator op(const 所属类型 &obj1,const 所属类型 &obj1) { 
    ..... //obj1和obj2分别对应两个运算对象 } 

例：将加减运算符重载为复数类的友元函数

讯享网#include<iostream> #include<string> #include<cmath> #include<algorithm> #include<cstring> #include<cstdlib> using namespace std; class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数 real=r; imag=i; } friend complex operator +(const complex &c1,const complex &c2); //重载+运算符 friend complex operator -(const complex &c1,const complex &c2); //重载-运算符 void display() { 
    cout<<real<<"+"<<imag<<"i"<<endl; } private: double real; //实部 double imag; //虚部  }; complex operator +(const complex &c1,const complex &c2) { 
    complex c3; c3.real=c1.real+c2.real; c3.imag=c1.imag+c2.imag; return c3; } complex operator -(const complex &c1,const complex &c2) { 
    complex c3; c3.real=c1.real-c2.real; c3.imag=c1.imag-c2.imag; return c3; } int main() { 
    complex c1(1,2),c2(3,4),c3; c3=c2+c1; c3.display(); //输出4+6i  c3=c2-c1; c3.display(); //输出2+2i  return 0; } 

2.前置单目运算符重载为类的友元函数，形式如下：

返回类型 operator op(const 所属类型 &obj) { 
    ..... //obj对应运算对象 } 

3.后置单目运算符重载为类的友元函数，形式如下：

讯享网返回类型 operator op(const 所属类型 &obj,int) { 
    ..... //obj对应运算对象 } 

例：将前置自增和后置自增运算符为复数类的友元函数

#include<iostream> #include<string> #include<cmath> #include<algorithm> #include<cstring> #include<cstdlib> using namespace std; class complex { 
    //复数类 public: complex(double r=0.0,double i=0.0) { 
    //构造函数 real=r; imag=i; } friend complex operator ++(complex &c1); //重载前置++ friend complex operator ++(complex &c1,int); //重载后置++  void display() { 
    cout<<real<<"+"<<imag<<"i"<<endl; } private: double real; //实部 double imag; //虚部  }; complex operator ++(complex &c1) { 
    complex c; c1.real++; c1.imag++; c.real=c1.real; c.imag=c1.imag; return c; } complex operator ++(complex &c1,int) { 
    complex c; c.real=c1.real; c.imag=c1.imag; c1.real++; c1.imag++; return c; } int main() { 
    complex c1(1,2),c2,c3; c2 = ++c1; c1.display(); //输出2+3i  c2.display(); //输出2+3i  c3 = c1++; c1.display(); //输出3+4i  c3.display(); //输出2+3i  return 0; }