C++运算符重载

C++ 重载运算符

在C++中，重载大部分 C++ 内置的运算符。

运算符函数是一种特殊的成员函数或友元函数。成员函数的语句格式为：

类型  类名：：operatorop（参数表）

{

   //相对于该类定义的操作

}

如下面的例子：

[/demo]

 

#include <iostream.h>

class Complex

{

private:

       double real;

         doubleimag;

 

public:

         Complex(){real=0,imag=0;}

         Complex(doubler,double i){real=r; imag=i;}

         Complex operator + (Complex &c2);

         voiddisplay( );

};

Complex Complex:: operator + (Complex &c2) {

         return Complex(real+c2.real, imag+c2.imag);}

void Complex::display( ){

         cout<<"("<<real<<","<<imag<<"i)"<<endl;}

int main( ){

         Complexc1(3,4),c2(5,-10),c3;

         c3=c1+c2;

         cout<<"c1=";c1.display();

         cout<<"c2=";c2.display();

         cout<<"c1+c2=";     c3.display( );

         return0;

}

 

C++语言中大部分预定义的运算符都可以被重载。

可重载的运算符：

+ -  *  / %  ^  & |  ~  ! ,  =

< >  <= >= ++ --  << >> == != && ||

+= -= /= %= ^= &= |= *= <<=   >>=  [] ()

-> ->*   new  new []   delete   delete []

不可重载的运算符：

:: .* . ?:

 

重载运算符的限制：

1. 重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
2. 不改变运算符的优先级
3. 不改变运算符的结合性
4. 不改变运算符所需要的操作数
5. 不能创建新的运算符

 

下面的实例简单介绍几种运算符重载（部分代码取自网络）：

 

• 下面演示了如何重载一元减运算符（ - ）。

[demo]

 

#include <iostream>

using namespace std;

 

class Distance

{

  private:

     int feet;             // 0 到无穷

     int inches;           // 0 到 12

   public:

     // 所需的构造函数

     Distance(){

        feet = 0;

        inches = 0;

     }

     Distance(int f, int i){

        feet = f;

        inches = i;

     }

     // 显示距离的方法

     void displayDistance()

     {

        cout << "F: " << feet << " I:"<< inches <<endl;

     }

     // 重载负运算符（ - ）

      Distance operator-() 

      {

         feet = -feet;

         inches = -inches;

         return Distance(feet, inches);

      }

};

int main()

{

  Distance D1(11, 10), D2(-5, 11);

 

   -D1;                     // 取相反数

  D1.displayDistance();    // 距离 D1

 

   -D2;                     // 取相反数

  D2.displayDistance();    // 距离 D2

  return 0;

}

 

[/demo]

 

当上面的代码被编译和执行时，它会产生下列结果：

F: -11 I:-10

F: 5 I:-11

• C++ 输入/输出运算符重载

C++ 能够使用流提取运算符 >> 和流插入运算符<< 来输入和输出内置的数据类型。

在这里，有一点很重要，需要把运算符重载函数声明为类的友元函数，这样我们就能不用创建对象而直接调用函数。

下面是如何重载提取运算符 >> 和插入运算符 <<。

 

[/demo]

 

#include <iostream>

using namespace std;

class Distance

{

  private:

     int feet;             // 0 到无穷

     int inches;           // 0 到 12

  public:

     // 所需的构造函数

     Distance(){

        feet = 0;

        inches = 0;

     }

     Distance(int f, int i){

        feet = f;

        inches = i;

     }

      friend ostream&operator<<( ostream &output, const Distance &D )

      {

         output << "F : "<< D.feet << " I : " << D.inches;

         return output;           

      }

      friend istream &operator>>(istream  &input, Distance &D )

      {

         input >> D.feet >>D.inches;

         return input;           

      }

};

int main()

{

  Distance D1(11, 10), D2(5, 11), D3;

  cout << "Enter the value of object : " << endl;

   cin >> D3;

   cout <<"First Distance : " << D1 << endl;

   cout << "Second Distance :"<< D2 << endl;

   cout << "Third Distance :"<< D3 << endl;

  return 0;

}

 

[/demo]

 

当上面的代码被编译和执行时，它会产生下列结果：

Enter the value of object :

70

10

First Distance : F : 11 I : 10

Second Distance :F : 5 I : 11

Third Distance :F : 70 I : 10

 

•  C++ 函数调用运算符 () 重载

函数调用运算符 () 可以被重载用于类的对象。

下面是如何重载函数调用运算符 ()。

 

[demo]

 

#include <iostream>

using namespace std;

class Distance

{

  private:

     int feet;             // 0 到无穷

     int inches;           // 0 到 12

  public:

     // 所需的构造函数

     Distance(){

        feet = 0;

        inches = 0;

     }

     Distance(int f, int i){

        feet = f;

        inches = i;

     }

     // 重载函数调用运算符

     Distance operator()(int a, int b, int c)

      {

         Distance D;

         // 进行随机计算

         D.feet = a + c + 10;

         D.inches = b + c + 100 ;

         return D;

      }

     // 显示距离的方法

     void displayDistance()

     {

        cout << "F: " << feet <<  " I:" <<  inches << endl;

     }    

};

int main()

{

  Distance D1(11, 10), D2;

  cout << "First Distance : ";

  D1.displayDistance();

   D2 = D1(10, 10, 10); // invoke operator()

  cout << "Second Distance :";

  D2.displayDistance();

  return 0;

}

 

[/demo]

 

当上面的代码被编译和执行时，它会产生下列结果：

First Distance : F: 11 I:10

Second Distance :F: 30 I:120

 学习心得：运算符重载实现了用我们熟知的运算符来实现更加复杂的数据类型的计算，使得程序更加简洁、高效，可以更加直观的和系统的看出复杂数据的计算。