操作符重载operator

Posted 邗影

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了操作符重载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);
}

  

以上是关于操作符重载operator的主要内容,如果未能解决你的问题,请参考以下文章

操作符重载operator

错误:“int”和“<未解析的重载函数类型>”类型的无效操作数到二进制“operator/”

重载[] int& operator[ ]( )

C++中operator关键字(重载操作符)

[C++潜心修炼] operator重载

operator 的两种用法