C++运算符重载

感觉得乱，看上面的目录就清对了

^_^

^_^

^_^

知识点 1-运算符符重载该有返回值

1.重载操作符时至少要有一个对象参与，而且最好带返回值；

带返回值的好处就是，能实现表达式的连续运算，

比如下面的例子，如果重载函数无返回值则重载后运算符只能实现 a=123;

无法实现形如a=b=100这类赋值

代码如下如下：

例1-1 运算符重载无返回值

#include<iostream>
using namespace std;
class CNum
{
public:
int a;
public:
CNum()
{
a=100;
}
void operator= (int num)
{
this->a=num;
}
};
int main()
{
CNum num1;
num1=123; //理解为num1调用操作符，将123作为参数传进去
cout<<num1.a<<endl  ;
return 0;
}

此时num1,调用了重载的运算符，123作为参数传进了重载函数，实现了通过重载后的运算符对类对象的赋值。但主函数中如果如下则会出错：

int main()
{
CNum num1;
CNum num2;
num2=num1=123;//由于重载的“=”运算符无返回值，表达式没结果，所以出错。其中num1=123可以完成操作的
}

所以为了实现连续的操作做如下改动：

例1-2运算符重载有返回值

#include<iostream>
ing namespace std;
class CNum
{
public:
int a;
public:
CNum()
{
a=100;
}
int operator= (int num)
{
this->a=num;
return a;
}
};
int main()
{
CNum num1;
CNum num2;
num2=num1=666; //先执行num1=666,再执行num2=返回值（a）
cout<<num1.a<<endl  ;
cout<<num2.a<<endl  ;
return 0;
}

当我们重载运算符是时，一定要合理适应返回值，这样能实现连续运算，连接其他符号：

比如：a+b+c;a*b+c*d/f ….之类的

知识点2：双目运算符重载：

- 对象在左边：类内重载；

- 对象在右边：类外重载（需要两个参数)；

因为全局函数不需要类对象，第一个参数符号左边的，第二个参数是符号右边的。

两边都有对象，考虑实际情况 ；

例2-1、对象在左边 ， 类内重载

实现 b=a+100;

#include<iostream>
using namespace std;
class CNum
{
public:
int a;
public:
CNum()
{
a=100;
}
int operator+(int num)
{
return  this->a+num  ;
}
int operator= (int num)
{
this->a=num;
return a;
}

};
int main()
{
CNum num1;
CNum num2;
num1=666;
num2=num1+100;
cout<<num1.a<<endl  ;
cout<<num2.a<<endl  ;
return 0;
}

运行结果如图：

例2-2、对象在右 ， 类外重载

实现b=100+a;

#include<iostream>
using namespace std;
class CNum//定义一个类
{
public:
int a;
public:
CNum()//构造器
{
a=100;
}
int operator+(int num)//重载+，有返回值
{
return  this->a+num  ;
}
int operator= (int num)//对象在左，类内重载
{
this->a=num;
return a;
}

};
int operator +(int tem,CNum & num)//对象在右，类外重载
{
return tem+num.a;
}
int main()
{
CNum num1;
CNum num2;
CNum num3;
num1=666;

num2=num1+100;
num3=100+num2;

cout<&l
4000
t;num1.a<<endl  ;
cout<<num2.a<<endl  ;
cout<<num3.a<<endl  ;
return 0;
}

运行结果如图：

例2-3 两边都有对象，考虑实际情况

实现：对 << 的重载

比如： cout << a

对象 << 对象

cout 是ostream类的对象；

a 是CNum类的对象；

考虑到，如果要是在类内重载，应该将代码写到ostream类中，显然这样很不好，所有毫不犹豫选择了，类外重载，代码如下；

#include<iostream>
using namespace std;
class CNum
{
public:
int a;
public:
CNum()
{
a=100;
}
int operator+(int num)
{
return  this->a+num  ;
}
int operator= (int num)
{
this->a=num;
return a;
}

};
/*------------类外重载-----------*/
int operator +(int tem,CNum & num)
{
return tem+num.a;
}
//下面这个实现了    cout<<a;
//但是没实现    cout<<a<<endl;因为没有返回值继续传递
//void  operator <<(ostream & os,CNum &num)
//              //输出流只能引用
//{
//    os<<num.a;
//
//
//}
//
ostream &  operator <<(ostream & os,CNum &num)

{
os<<num.a;

return os;
}
int main()
{
CNum num1;
CNum num2;
CNum num3;
num1=666;

num2=num1+100;
num3=100+num2;
//未重载前的输出
cout<<num1.a<<endl  ;
cout<<num2.a<<endl  ;
cout<<num3.a<<endl  ;
//重载后的输出，注意有返回值，才能连续使用<< ，看代码
cout<<num1<<endl    ;
cout<<num2<<endl    ;
cout<<num3<<endl    ;
return 0;
}

输出如图所示：

知识点3-单目运算符重载

单目运算符重载，类内类外都可以

例3-1、实现对单目运算符++的重载 ：

a++；++a；

include<iostream>
using namespace std;
class CNum
{
public:
int a;
CNum()
{
a=100;
}
//同一作用域有两个名字一样的函数，只能通过函数重载解决
public:
int operator ++()  //  ++a
{
a=a+1;
return a;
}
int operator ++(int tem)  //  ++a
{
tem =a;
a=a+1;
return tem;
}
};
int main()
{
CNum num1;
CNum num2;
cout<<num1++<<endl;
cout<<++num2<<endl;

return 0;
}

输出结果如图：