C++中的運算符重載

四種不能重載的運算符：

1> ::    域運算符

2> .     成員訪問運算符

3> *    成員 指針訪問運算符((*this).member)

4>:?    三目運算符

只能用友元重載的運算符:

1> <<   輸出運算符重載

2>  >>   輸入運算符重載

即能聲明友元又能聲明爲類的成員函數的運算符重載：

1>  四則運算符

2>   ++ --運算符

3>   != == +=  -=  *=  /= 運算符

只能聲明爲類的成員函數的運算符

1>[]  下標運算符

2>()  

3> ->  

4>=   賦值運算符

一般不用重載的運算符

1>=

2>&

3>*

另外重載只能是現有的運算符，且重載後不能改變運算符的優先級。

下面是一個例子：

//
//  Complex.h
//  train5
//
//  Created by student on 15/8/11.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#ifndef __train5__Complex__
#define __train5__Complex__

#include <iostream>
using namespace std;
class Complex{
public:
    Complex(int r1=0,int i1=0);
    ~Complex(){}
    const Complex& operator--();         //前置減減(實部減一，虛部不變)
    const Complex operator--(int);       //後置減減
    
    friend const Complex operator+(const Complex& p1,const Complex& p2);
    friend const Complex operator-(const Complex& p1,const Complex& p2);
    friend const Complex operator*(const Complex& p1,const Complex& p2);
    friend const Complex operator/(const Complex& p1,const Complex& p2);
    friend Complex operator+=(Complex& c1,const Complex& c2);
    friend Complex operator-=(Complex& c1,const Complex& c2);
    friend Complex operator*=(Complex& c1,const Complex& c2);
    friend Complex operator/=(Complex& c1,const Complex& c2);
    
    friend ostream& operator<<(ostream& out,const Complex& c1);
    friend bool operator==(const Complex& c1,const Complex& c2);
    friend bool operator!=(const Complex& c1,const Complex& c2);
    
private:
    int r,i;
};

#endif /* defined(__train5__Complex__) */

//
//  Complex.cpp
//  train5
//
//  Created by student on 15/8/11.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#include "Complex.h"
Complex::Complex(int r1,int i1){
    r=r1;
    i=i1;
}

const Complex operator+(const Complex& p1,const Complex& p2){
    return Complex(p1.r+p2.r,p1.i+p2.i);
}
const Complex operator-(const Complex& p1,const Complex& p2){
    return Complex(p1.r-p2.r,p1.i-p2.i);
}
const Complex operator*(const Complex& p1,const Complex& p2){
    return Complex(p1.r*p2.r-p1.i*p2.i,p1.r*p2.i+p1.i*p2.r);
}
const Complex operator/(const Complex& p1,const Complex& p2){
    float den=p2.r*p2.r+p2.i*p2.i;
    return Complex((p1.r*p2.r+p1.i*p2.i)/den,(-p1.r*p2.i+p1.i*p2.r)/den);
}

Complex operator+=(Complex& c1,const Complex& c2){
    c1=c1+c2;
    return c1;
}
Complex operator-=(Complex& c1,const Complex& c2){
    c1=c1-c2;
    return c1;
}
Complex operator*=(Complex& c1,const Complex& c2){
    c1=c1*c2;
    return c1;
}
Complex operator/=(Complex& c1,const Complex& c2){
    c1=c1/c2;
    return c1;
}

/*const Complex& Complex::operator--(){
    this->r-=1;
    return *this;
}*/

/*const Complex Complex::operator--(int){
    Complex old = (*this);
    --(*this);
    return old;
}*/

const Complex& Complex::operator--(){
    Complex c(1,0);
    (*this)=(*this)-c;
    return *this;
}

const Complex Complex::operator--(int){
    Complex old = (*this);
    Complex c(1,0);
    (*this)=(*this)-c;
    return old;
}

ostream& operator<<(ostream& out,const Complex& c1){
    out<<"r="<<c1.r<<",i="<<c1.i<<endl;
    return out;
}

bool operator==(const Complex& c1,const Complex& c2){
    if ((c1.r==c2.r) && (c1.i==c2.i)) {
        return true;
    }
    else{
        return false;
    }
}
bool operator!=(const Complex& c1,const Complex& c2){
    if ((c1.r==c2.r) && (c1.i==c2.i)) {
        return false;
    }
    else{
        return true;
    }
}

//
//  main.cpp
//  train5
//
//  Created by student on 15/8/11.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#include <iostream>
#include "Complex.h"
int main(int argc, const char * argv[])
{

    // insert code here...
    Complex c1(1,3),c2(4,5);
    Complex c;
    c1+=c2;
    cout<<c1;
    c1-=c2;
    cout<<c1;
    c1*=c2;
    cout<<c1;
    c1/=c2;
    cout<<c1;
    c1--;
    --c1;
    cout<<c1;
    if (c1==c2) {
        cout<<"c1==c2\n";
    }
    else if (c1!=c2){
        cout<<"c1!=c2\n";
    }
    //std::cout << "Hello, World!\n";
    return 0;
}

下面是對運算符()和->的重載，它們的作用分別是，賦值操作和普通對象也能調用 ->

//
//  Complex.h
//  重載運算符
//
//  Created by student on 15/8/16.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#ifndef _________Complex__
#define _________Complex__

#include <iostream>
using namespace std;

class Complex{
public:
    Complex(float x=0,float y=0){
        r=x;i=y;
    }
    ~Complex(){}
    
    const Complex& operator()(const Complex& c);
    const Complex* operator->();
    friend ostream& operator<<(ostream& os,const Complex& c);
    void print() const{
        cout<<"r="<<r<<",i="<<i<<endl;
    }
private:
    float r,i;
};

#endif /* defined(_________Complex__) */

//
//  Complex.cpp
//  重載運算符
//
//  Created by student on 15/8/16.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#include "Complex.h"

const Complex& Complex::operator()(const Complex &c){
    i = c.i;
    r = c.r;
    cout<<"Operator () is called!\n";
    return *this;
}

const Complex* Complex::operator->(){
    cout<<"Opeartor -> is called!\n";
    return this;
}

ostream& operator<<(ostream& os,const Complex& c){
    os<<"r="<<c.r<<",i="<<c.i<<endl;
    return os;
}

//
//  main.cpp
//  重載運算符
//
//  Created by student on 15/8/16.
//  Copyright (c) 2015年 personals. All rights reserved.
//

#include <iostream>
#include "Complex.h"
int main(int argc, const char * argv[])
{

    // insert code here...
    Complex c1,c2(2,3);
    c1(c2);
    c1->print();
    cout<<c1<<c2;
    //std::cout << "Hello, World!\n";
    return 0;
}