欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-05-15 21:08:25
一、重载运算符 在c++中,不只是函数可以重载,某些运算符也是可以重载的,即可以自定义运算符的功能,可以重载的运算符如下: 运算符 名称 类型 , 逗号 二进制 ! 逻辑&l...

一、重载运算符

在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 
*/  
"分>"分>
;>"分";>;>;>"分";>