c++之运算符重载一

可以重载的运算符

+  -  *  /  %  ^  &  |  ~

!  =  <  >  +=  -=  *=  /=  %

^=  &=  |=  <<  >>  >>=  <<=  ==  !=

<=  >=  &&  ||  ++  --  ->*  ‘  ->

[]  ()  new  delete  new[]  delete[] 

不能重载的算符 

.  ::  .*  ?:  sizeof

重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：

不改变运算符的优先级

不改变运算符的结合性

不改变运算符所需要的操作数

不能创建新的运算符

#include <iostream>
#include <cstdlib>
using namespace std;

class A
{
public:
    A()
    {
        value = 0;
    };
    //声明重载的运算符函数
    void operator ++();
    void operator --();
    unsigned int operator ()();

private:
    unsigned int value;
};

void A::operator++()
{
    if(value<65535)
    {
        value ++;    //使用了系统预定义版本
    }else
    {
        cout << "
Data overflow!"<<endl;
        exit(0);
    }
}
void A::operator--()
{
    if(value>0)
    {
        value --;    //使用了系统预定义版本
    }else
    {
        cout << "
Data overflow!" << endl;
        exit(0);
    }
}
unsigned int A::operator()()
{
    return value;
}
void main2()
{
    A a;
    int i;
    for(i=0;i<5;i++)
    {
        ++a;    //调用重载版本
        cout << "
a=" << a();    //a（）调用重载的（）
    }
    for(i=0;i<=5;i++)
    {
        --a;    //调用重载版本
        cout << "
a=" << a();    //a（）调用重载的（）
    }
}

使用成员函数来重载运算符

#include <iostream>
using namespace std;

//用成员函数重载 + 、++ 、= 运算符，实现一个简单的三维坐标的计算
class ThrCoor
{
public:
    ThrCoor(int x=0,int y=0,int z=0)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
    void  operator ++()
    {
        x ++;
        y ++;
        z ++;
    }
    ThrCoor operator +(ThrCoor t)
    {
        ThrCoor temp;
        temp.x = x + t.x;
        temp.y = y + t.y;
        temp.z = z + t.z;
        return temp;
    }
    ThrCoor /*dengyu*/operator =(ThrCoor t)
    {
        x = t.x;
        y = t.y;
        z = t.z;
        return *this;
    }
    void show()
    {
        cout << x << '	' << y << '	' << z << endl;
    }
    void set(int x,int y,int z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
private:
    int x,y,z;
};

void main()
{
    ThrCoor a(1,2,3),b,c;
    a.show();
    b.show();
    c.show();
    for(int i=0;i<5;i++)
    {
        b++;
    }
    b.show();
    c.set(3,3,3);
    c = a + b + c;
    c.show();
    c = b = a;
    //c.dengyu(b.dengyu(a));
    c.show();
}

#include <iostream>
using namespace std;

//用成员函数重载 + 、++ 、= 运算符，实现一个简单的三维坐标的计算
class ThrCoor
{
public:
    ThrCoor(int x=0,int y=0,int z=0)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
    void  operator ++()
    {
        x ++;
        y ++;
        z ++;
    }
    ThrCoor operator +(ThrCoor t)
    {
        ThrCoor temp;
        temp.x = x + t.x;
        temp.y = y + t.y;
        temp.z = z + t.z;
        return temp;
    }
    ThrCoor /*dengyu*/operator =(ThrCoor t)
    {
        x = t.x;
        y = t.y;
        z = t.z;
        return *this;
    }
    void show()
    {
        cout << x << '	' << y << '	' << z << endl;
    }
    void set(int x,int y,int z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
private:
    int x,y,z;
};

void main()
{
    ThrCoor a(1,2,3),b,c;
    a.show();
    b.show();
    c.show();
    for(int i=0;i<5;i++)
    {
        b++;
    }
    b.show();
    c.set(3,3,3);
    c = a + b + c;
    c.show();
    c = b = a;
    //c.dengyu(b.dengyu(a));
    c.show();
}

使用友元函数重载运算符

在第一个参数需要隐式转换的情形下，使用友元函数重载

    运算符是正确的选择

友元函数没有 this 指针，所需操作数都必须在参数表显式

    声明，很容易实现类型的隐式转换

c++中不能用友元函数重载的运算符有

  =    （）    ［］    －>

#include <iostream>
using namespace std;
//用友元函数重载运算符
//友元函数重载运算符常用于运算符的左右操作数的类型不同的情况

class Complex
{
public:
    Complex(double real=0,double image=0)
    {
        this->real = real;
        this->image = image;
    }
    Complex(int a)
    {
        this->real = a;
        this->image = 0;
    }
    friend Complex operator +(const Complex &real,const Complex &image);
    friend Complex operator -(Complex &real,Complex &image);
    friend Complex operator -(Complex &real);
    void print();
private:
    double real,image;
};

Complex operator+(const Complex &real,const Complex &image)
{
    double r = real.real + image.real;
    double i = real.image + image.image;
    return Complex(r,i);
}
Complex operator-(Complex &real,Complex &image)
{
    double r = real.real - image.real;
    double i = real.image - image.image;
    return Complex(r,i);
}
Complex operator-(Complex &real)
{
    double r = -real.real;
    double i = -real.image;
    //构造返回对象
    return Complex(r,i);
}
void Complex::print()
{
    cout << "(" << real << "," << image << ")" << endl;
}

void main()
{
    Complex c1(2.5,3.7),c2(4.2,6.5),c;
    c = c1 - c2;
    c.print();
    //构造形参对象，把整形常数25，转换成Complex（25,0）；
    c = 25 + c2;
    c.print();
    c = c2 + 25;
    c.print();
    c = -c1;
    c.print();
}