C++运算符重载

所谓重载，就是重新赋予新的含义，函数重载就是对一个已有的函数赋予新的含义，使之实现新功能｡
运算符的重载主要存在两种形式，一种是作为类的成员函数进行使用，另一种则是作为类的友元函数进行使用。运算符的重载的形式为：
   返回类型 operator 运算符符号（参数说明）
    {    
           //函数体的内部实现
    }
例如，能否用“+”号进行两个复数的相加，在C++中不能在程序中直接用运算符“+”对复数进行相加运算，用户必须自己设法实现复数相加。例如用户可以通过定义一个专门的函数来实现复数相加。

/*
实现复数类中的运算符重载
定义一个复数类重载运算符+、-、*、/，使之能用于复数的加减乘除。
方案一：使用类的成员函数完成运算符的重载；
*/
#include<iostream>
using namespace std;

class Complex
{
private:
    double real;
    double imag;
public:
    Complex()
    {
        real = 0 ; imag = 0 ;
    }
    Complex(double r,double i)
    {
        real = r ; imag = i ;
    }
    Complex operator+(Complex &c2);
    Complex operator-(Complex &c2);
    Complex operator*(Complex &c2);
    Complex operator/(Complex &c2);
    void display();
};

//下面定义成员函数
Complex Complex::operator+(Complex &c2) //定义重载运算符”+“的函数
{
    return Complex(this->real+c2.real , this->imag+c2.imag);   //此处this->real就是c1.real
}
Complex Complex::operator-(Complex &c2)//定义重载运算符”-“的函数
{
    return Complex(this->real-c2.real , this->imag-c2.imag);   //此处this->real就是c1.real
}

Complex Complex::operator*(Complex &c2)  
{
    return Complex(this->real*c2.real , this->imag*c2.imag);   //此处this->real就是c1.real  
}

Complex Complex::operator/(Complex &c2)  
{
    Complex c;      
    c.real = (real*c2.real + imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);      
    c.imag = (-real*c2.imag + imag*c2.real)/(c2.real*c2.real+c2.imag*c2.imag);     
    return c;      
}   

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main(void)
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;   // 此处相当于非重载运算符函数中的“c3=c1.Complex_add(c2)
    //将运算符+重载为类的成员函数后，编译系统会将程序中的表达式c1+c2解释为：c1.operator+(c2)即以c2为实参调用c1的运算符重载函数operator+(Complex&c2),operator+是类的一个函数名
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

 

运算符重载运算符的运算规则
      ①运算符重载函数也是函数，重载的运算符不会改变运算符的优先级、结合型和参数的个数。
      ②重载运算符不能违反语言的语法规则。
      ③赋值运算符除外，重载运算符可由派生类继承下去。
      ④重载运算符不能使用默认参数。
      ⑤运算符=、()、[]和->等操作符必须定义为类的成员函数，将这些操作符定义为友元函数将在编译时标记为错误。
      ⑥C++中不能重载的运算符只有5个:
       .  (成员访问运算符)
       .* (成员指针访问运算符)
       ∷ (域运算符)
       sizeof(长度运算符)
       ?: (条件运算符)
      因为前两个运算符不能重载是为了保证访问成员的功能不能被改变,域运算符和sizeof运算符的运算对象是类型而不是变量或一般表达式,不具重载的特征｡总结：带点'.'的都不能重载，new和delete神马的也可以重载！
      ⑦友元运算符的参数规则与类成员运算符的参数规则不同，一员运算符必须显示地声明一个参数，二员运算符必须显示地声明两个参数。类成员运算符重载时，参数中隐含了一个this指针。（另外，C++规定，有的运算符（如赋值运算符、下标运算符、函数调用运算符）必须定义为类的成员函数，有的运算符则不能定义为类的成员函数（如流输入“>>”和流输出“<<”运算符、类型转换运算符））。
重载为类的成员函数时，参数个数=原操作数个数-1（后置++、--除外），它可以通过this指针自由地访问本类的数据成员，可以少写一个函数的参数，但必须要求运算表达式的第一个参数（即运算符左侧的操作数）是一个类对象。
重载为类的友元函数时，参数个数=原操作数个数，且至少应该有一个自定义类型的形参。

 

如何重载增量运算符 ++ 和 --
    运算符++和—有前置和后置两种形式，如果不区分前置和后置，则使用operator++( )或operator--( )即可；否则，要使用operator++( )或operator--( )来重载前置运算符，使用operator++(int)或operator--(int)来重载后置运算符，调用时，参数int被传递给值0。如下列程序段：

 

//重载增量运算符 ++ 和 --
#include<iostream>
using namespace std;

class Complex
{
private:
    int x;
    int y;
public:
    Complex()    //定义构造函数
    {
        x = 0 ; y = 0 ;
    }
    Complex(int a,int b)    //构造函数重载
    {
        x = a ; y = b ;
    }
    void display();
    Complex operator ++();      //前置自增方式
    Complex operator ++(int);   //后置自增方式（增加一个int类型的形参）
};

Complex Complex::operator ++()
{
    x = x + 1;
    y = y + 1;
    return *this;
}
Complex Complex::operator ++(int)
{
    Complex temp(*this);
    x = x + 1;
    y = y + 1;
    return temp;
}
void Complex::display()  
{  
    cout<<"("<<x<<","<<y<<")"<<endl;  
}
int main(void)
{
    Complex c1(3,4),c2(5,-10),c3;
    c3 = c1++;
    cout<<"c1++=";
    c3.display();
    c3 = ++c2;
    cout<<"++c2=";
    c3.display();
    return 0;
}

 

 

重载流输入运算符和流输出运算符

istream  类的对象cin;
ostream类的对象cout;
如果想直接用“<<”和“>>”输出和输入自己声明的类型的数据，必须对它们重载，对“<<”和“>>”重载的函数形式如下：
istream & operator >> (istream &，自定义类 &);
ostream & operator << (ostream &，自定义类 &);
重载运算符“>>”的函数的第一个参数和函数的类型都必须是istream&类型，第二个参数是要进行输入操作的类。
重载“<<”的函数的第一个参数和函数的类型都必须是ostream&类型，第二个参数是要进行输出操作的类。
只能将重载“>>”和“<<”的函数作为友元函数或普通的函数，而不能将它们定义为成员函数。
实现代码如下：

 

 

//增加重载流提取运算符“>>”，用“cin>>”输入复数，用“cout<<”输出复数。
#include<iostream>
using namespace std;

class Complex
{
private:
    double real;
    double imag;
public:
    Complex()    //定义构造函数
    {
        real = 0 ; imag = 0 ;
    }
    Complex(double r,double i)    //构造函数重载
    {
        real = r ; imag = i ;
    }
    friend istream& operator>>(istream & , Complex & );
    friend ostream& operator<<(ostream & , Complex & );
};

//下面定义友员函数 
istream& operator>>(istream & in, Complex &c)
{
    cout<<"input real part and imaginary part of complex number:";
    in>>c.real>>c.imag;
    return in;
}
ostream& operator<<(ostream & out, Complex &c)
{
    out<<'('<<c.real<<"+"<<c.imag<<"i)";
    return out;
}

int main(void)
{
    Complex c1 , c2;
    cin>>c1>>c2;
    cout<<"c1="<<c1<<endl;
    cout<<"c2="<<c2<<endl;
    return 0;
}

 

转载自http://blog.csdn.net/hackbuteer1/article/details/7554070