C++重载运算符和标准模板库实例讲解

一、重载运算符

在c++中，不只是函数可以重载，某些运算符也是可以重载的，即可以自定义运算符的功能，可以重载的运算符如下：

运算符	名称	类型
,	逗号	二进制
!	逻辑“非”	一元
!=	不相等	二进制
%	取模	二进制
%=	取模赋值	二进制
&	按位“与”	二进制
&	address-of	一元
&&	逻辑“与”	二进制
&=	按位“与”赋值	二进制
( )	函数调用	—
( )	强制转换运算符	一元
*	乘法	二进制
*	指针取消引用	一元
*=	乘法赋值	二进制
+	添加	二进制
+	一元加	一元
++	递增1	一元
+=	加法赋值	二进制
-	减法	二进制
-	一元求反	一元
--	递减1	一元
-=	减法赋值	二进制
->	成员选择	二进制
->*	指向成员的指针选定内容	二进制
/	除法	二进制
/=	除法赋值	二进制
<	小于	二进制
<<	左移	二进制
<<=	左移赋值	二进制
<=	小于或等于	二进制
=	赋值	二进制
==	相等	二进制
>	大于	二进制
>=	大于或等于	二进制
>>	右移	二进制
>>=	右移赋值	二进制
[ ]	数组下标	—
^	异或	二进制
^=	异或赋值	二进制
|	按位“与或”	二进制
|=	按位“与或”赋值	二进制
||	逻辑“或”	二进制
~	二进制反码	一元
delete	delete	—
new	new	—
conversion operators	转换运算符	一元

不可重载的运算符：

operator	name
.	成员选择
.*	指向成员的指针选定内容
::	范围解析
? :	条件运算
#	预处理器转换为字符串
##	预处理器串联

在将这些运算符重载之后，运算符就被赋予了的新的功能，重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表：

complex operator+(const complex&, const complex&);//重载+运算符 实现两个复数相加

部分运算符实例如下，实现过程见注释：
①：二元运算符重载

#include 
using namespace std;

class complex {//复数类
public:
double re, im;//实部 虚部
complex(){//无参构造函数
}
complex(double x,double y){//含参构造函数
 re=x;
 im=y;
}
complex operator+( complex &x );//重载+运算符  实现复数相加
void display( ) {cout << re << ", " << im << endl; }
};

complex complex::operator+( complex &x ) {
return complex( re + x.re, im + x.im );
}

int main() {
complex a = complex( 1.2, 3.4 );
complex b = complex( 5.6, 7.8 );
complex c = complex( 0.0, 0.0 );
c = a + b;
c.display();
}

②：关系运算符重载

#include
using namespace std;
class time//时间类
{
private:
 int month;
 int day;
 int hour;
 int minute;
public:
 time(int mon,int d,int h,int m){//含参构造函数
  month=mon;
  day=d;
  hour=h;
  minute=m;}
 time(){month=day=hour=minute=0;//无参构造函数
 }
 //重载<操作符  实现时间大小的比较
 bool operator<(const time &x){//如果时间t1
③：输入/输出运算符重载
#include
using namespace std;
class time//时间类
{
private:
 int month;
 int day;
 int hour;
 int minute;
public:
 time(int mon,int d,int h,int m){//含参构造函数
  month=mon;
  day=d;
  hour=h;
  minute=m;}
 time(){month=day=hour=minute=0;//无参构造函数
 }
 //重载<<操作符
  friend ostream &operator<<(ostream &out,const time &t){
out<>操作符
  friend istream &operator>>(istream &in,time &t){
in>>t.month>>t.day>>t.hour>>t.minute;
return in;
  }
};
int main()
{
 time x(8,8,8,8);
 time y;
 cout<>y;
 cout<
④：递增（++）递减（--）运算符重载
#include 
using namespace std;
class time
{
private:
int hours; // 0 到 23
int minutes;  // 0 到 59
public:
// 所需的构造函数
time(){
hours = 0;
minutes = 0;
}
time(int h, int m){
hours = h;
minutes = m;
}
// 显示时间的方法
void displaytime()
{
cout << hours << "点" << minutes <<"分"<= 60)
{
++hours;
minutes -= 60;
}
return time(hours, minutes);
}
// 重载后缀递增运算符（ ++ ）
time operator++( int )//int 用于区分前加和后加
{
// 创建临时对象，保存原始值
time t(hours, minutes);
// 对象加 1
++minutes;
if(minutes >= 60)
{
++hours;
minutes -= 60;
}
// 返回旧的原始值
return t;
}
/*重载前加和后加的区别:
*++i 直接把该对象的值+1 然后return该对象
*i++ 先创建临时对象temp 把原始值赋值给temp 然后对temp的数据+1 return temp
*两种加法产生的效果一样
*后加会添加一个形参int 用于区分前加还是后加 并无实际作用 operator++( int )
*/
};
int main()
{
time t1(11, 59), t2(10,40);

++t1;  // t1 加 1
t1.displaytime();  // 显示 t1
++t1;  // t1 再加 1
t1.displaytime();  // 显示 t1

t2++;  // t2 加 1
t2.displaytime();  // 显示 t2
t2++;  // t2 再加 1
t2.displaytime();  // 显示 t2
return 0;
}
/*当上面的代码被编译和执行时，它会产生下列结果：
*12点0分
*12点1分
*10点41分
*10点42分
*/
⑤：赋值运算符重载
#include
using namespace std;
class time//时间类
{
private:
 int month;
 int day;
 int hour;
 int minute;
public:
 time(int mon,int d,int h,int m){//含参构造函数
  month=mon;
  day=d;
  hour=h;
  minute=m;}
 time(){month=day=hour=minute=0;//无参构造函数
 }
 void display(){
  cout<
⑥：函数调用运算符() 下标运算符 [] 重载 【只能用成员函数重载 不能用友元函数重载】
#include 
using namespace std;

class distance
{
private:
int feet; // 0 到无穷
int inches;  // 0 到 12
public:
// 所需的构造函数
distance(){
feet = 0;
inches = 0;
}
distance(int f, int i){
feet = f;
inches = i;
}
// 重载函数调用运算符
distance operator()(int a, int b, int c)
{
distance d;
// 进行随机计算
d.feet = a + c + 10;
d.inches = b + c + 10 ;
return d;
}
// 显示距离的方法
void displaydistance()
{
cout << "f: " << feet <<  " i:" <<  inches << endl;
}

};
int main()
{
distance d1(11, 10), d2;

cout << "first distance : ";
d1.displaydistance();

d2 = d1(10, 10, 10); // invoke operator()
cout << "second distance :";
d2.displaydistance();

return 0;
}
/*当上面的代码被编译和执行时，它会产生下列结果：

first distance : f: 11 i:10
second distance :f: 30 i:30*/
//重载[]运算符

#include <iostream>  
using namespace std;  
const int size = 10;  
  
class safearay  
{  
   private:  
      int arr[size];  
   public:  
      safearay()   
      {  
         register int i;  
         for(i = 0; i < size; i++)  
         {  
           arr[i] = i;  
         }  
      }  
      int& operator[](int i)  
      {  
          if( i > size )  
          {  
              cout << "索引超过最大值" <<endl;   
              // 返回第一个元素  
              return arr[0];  
          }  
          return arr[i];  
      }  
};  
int main()  
{  
   safearay a;  
  
   cout << "a[2] 的值为 : " << a[2] <<endl;  
   cout << "a[5] 的值为 : " << a[5]<<endl;  
   cout << "a[12] 的值为 : " << a[12]<<endl;  
  
   return 0;  
}  
/* 
a[2] 的值为 : 2 
a[5] 的值为 : 5 
a[12] 的值为 : 索引超过最大值 
0 
*/  
"分>"分>
;>"分";>;>;>"分";>