操作符重载operator

发现一篇好文：

转载：

http://www.cnblogs.com/xiehongfeng100/p/4040858.html

#include <iostream>
#include <time.h>
using namespace std;
class C{
public:
int real;
int vertual;
C(int real,int vertual)
{

this->real=real;
this->vertual=vertual;
}
C operator+(C c2)。。。。。。。。。。。作为成员函数重载
{
return C(this->real+c2.real,this->vertual+c2.vertual);

}
};
int main()
{

C one(10,30);
C two(20,11);
C three(0,0);这句话之所以这样写是因为，构造函数重载了，就不会再有默认的无参构造，要想C THREE ,可以自己再写个无参构造函数
three=one+two;
cout<<three.real<<"_____"<<three.vertual<<endl;
return 0;

}

以上是+作为成员函数重载，和普通的全局函数以及友元函数不同，作为成员函数的时候由于有this指针，双目运算符只需要一个参数，单目运算符不需要参数

还有就是在自增自减运算符重载的时候，参数列表带int 参数的，表示后置，不带int的表示前置，，，，加一个int参数只是为的方便区分前后置，，，，ex：i++。。。++i

#include <iostream>
#include <time.h>
using namespace std;
class C{
public:
int real;
int vertual;
C(int real,int vertual)
{

this->real=real;
this->vertual=vertual;
}
C operator+(C c2)
{
return C(this->real+c2.real,this->vertual+c2.vertual);

}
friend C operator-(C c1,C c2);

};
C operator-(C c1,C c2)
{
return C(c1.real-c2.real,c1.vertual-c2.vertual);
}
int main()
{

C one(10,30);
C two(20,11);
C three(0,0);
three=one+two;
cout<<three.real<<"_____"<<three.vertual<<endl;
C four(0,0);
four=one-two;
cout<<four.real<<"_____"<<four.vertual<<endl;
return 0;

}

。。。。。。。。。。。。。。。。。。。。。。。。。

是类的成员函数或变量才可以加 --------类名::,友元函数外部定义的时候不加      。。。。。类名：：

对于成员函数重载运算符而言，双目运算符的参数表中仅有一个参数，而单目则无参数。同样的是重载，为什么和友元函数在参数的个数上会有所区别的。原因在于友元函数，没有this指针。

对于双目运算符而言，运算符重载函数的形参中仅为一个参数，它作为运算符的右操作数(如com2对象)，而当前对象作为左操作数(如：上述中的com1对象)，它是通过this指针隐含传递给成员运算符重载函数的。（转）

在运算符重载运用时应该注意以下几个问题：

　　(1) C++中只能对已有的C++运算符进行重载，不允许用户自己定义新的运算符;

　　(2) C++中绝大部分的运算符可重载，除了成员访问运算符.，成员指针访问运算符.*，作用域运算符::，长度运算符sizeof以及条件运算符?:;

　　(3) 重载后不能改变运算符的操作对象(操作数)的个数。如："+"是实现两个操作数的运算符，重载后仍然为双目运算符;

　　(4) 重载不能改变运算符原有的优先级;

　　(5) 重载不能改变运算符原有结合的特性。比如：z=x/y*a，执行时是先做左结合的运算x/y，重载后也是如此，不会变成先做右结合y*a;

　　(6) 运算符重载不能全部是C++中预定义的基本数据，这样做的目的是为了防止用户修改用于基本类型数据的运算符性质;

class Complex //复数类
{
private://私有
double real;//实数
double imag;//虚数
public:
Complex(double real = 0, double imag = 0)
{
this->real = real;
this->imag = imag;
}
Complex operator+(int x);
};

Complex Complex::operator+(int x)
{
return Complex(real + x, imag);
}

int main()
{
Complex com1(5, 10), total;
total = com1 + 5;
// total = 5 + com1; // 编译不通过
return 0;
}

如果我们把上述main()主函数实现部分里的total=com1+5改为total=5+com1;那么程序就会报错(没有与这些操作数匹配的 "+" 运算符)，因为左操作数5不是该复数类的对象，不能调用相应的成员函数Complex operator+(int x)，所以编译错误。但如果我们定义一下两个友元函数就能解决上述的问题：

1 friend Complex operator+(Complex com1, int x);
2 friend Complex operator+(int x, Complex com1);

单目运算符成员函数重载：

void operator++()
{
++this->real;
++this->vertual;

}
void operator++(int)后置
{
this->real++;
this->vertual++;
}

。。。。。。。。。。。。。

void operator++(C& c1)
{
++c1.real;
++c1.vertual;
}注意用友元函数重载单目运算符的时候要用引用，，，否则不生效，传的是一个副本。注意上边那个是前置，不用加int，，后置的时候还要多一个参数。

　

　插入运算符"<<"是双目运算符，左操作数为输出流类ostream的对象，右操作数为系统预定义的基本类型数据。头文件iostrem对其重载的函数原型为ostream& operator<<(ostream& ,类型名);类型名就是指基本类型数据。但如果要输出用户自定义的类型数据的话，就需要重载操作符"<<"，因为该操作符的左操作数一定为ostream类的对象，所以插入运算符"<<"只能是类的友元函数或普通函数，不能是其他类的成员函数。一般定义格式：

ostream& operator<<(ostream& ,自定义类名&);

　　提取运算符">>"也是如此，左操作数为istream类的对象，右操作数为基本类型数据。头文件iostrem对其重载的函数原型为istream& operator>>(istream& ,类型名);提取运算符也不能作为其他类的成员函数，可以是友元函数或普通函数。它的一般定义格式为：

istream& operator>>(istream& ,自定义类名&);

　插入操作符重载：

#include <iostream>
#include <time.h>
using namespace std;
class test{
public:
int real;
int vertual;
test(int real,int vertual)
{

this->real=real;
this->vertual=vertual;
}
friend ostream& operator<<(ostream& o,test& t);
friend istream& operator>>(istream& i,test& t);

};
ostream& operator<<(ostream& o,test& t)
{
cout<<"out operator:"<<endl;
o<<t.real<<"..."<<t.vertual<<endl;
return o;
}
istream& operator>>(istream& i,test& t)
{
cout<<"in operator"<<endl;
i>>t.real;
i>>t.vertual;
return i;
}
int main()
{
test t(10,20);
cout<<t;
cin>>t;
cout<<t;
return 0;
}

一般的重载

class A
{
public:
    A(int d) :data(d){}
    A operator+(A&);//成员函数
    A operator-(A&);
    A operator*(A&);
    A operator/(A&);
    A operator%(A&);
    friend A operator+(A&, A&);//友元函数
    friend A operator-(A&, A&);
    friend A operator*(A&, A&);
    friend A operator/(A&, A&);
    friend A operator%(A&, A&);
private:
    int data;
};

//成员函数的形式
A A::operator+(A &a)
{
    return A(data + a.data);
}
A A::operator-(A &a)
{
    return A(data - a.data);
}

A A::operator*(A &a)
{
    return A(data*a.data);
}
A A::operator/(A &a)
{
    return A(data / a.data);
}
A A::operator%(A &a)
{
    return A(data%a.data);
}

//友元函数的形式
A operator+(A &a1, A &a2)
{
    return A(a1.data + a2.data);
}
A operator-(A &a1, A &a2)
{
    return A(a1.data - a2.data);
}
A operator*(A &a1, A &a2)
{
    return A(a1.data*a2.data);
}
A operator/(A &a1, A &a2)
{
    return A(a1.data / a2.data);
}
A operator%(A &a1, A &a2)
{
    return A(a1.data%a2.data);
}