operator 类型转换及重载-白红宇

operator 类型转换及重载

阅读量：4007 次

发布时间：2019-05-24

本文共 3484 字，大约阅读时间需要 11 分钟。

一、类型转换

类型转换函数的一般形式为 :

operator

()

{实现转换的语句}

在函数名前面不能指定函数类型,函数没有参数.

如：

Complex::operator double()

{

return m_dReal;

}

int main()

{

Complex obj(3,4);

double dNum = 0.0;

dNum = 2.5 + obj;

cout<<"dNum="<<dNum<<endl;//dNum=5.5

return 0;

}

如果在Complex类中没有定义类型转换函数operator double,

将出错. 因为不能实现double型数据与Complex类对象相加. 现在,一定了成员函数operator double, 就可以利用它将Complex类对象转换为double型数据. 请注意 : 程序中不必显式地调用类型转换函数,它是自动被调用的,即

类型转换操作符（type conversion operator）是一种特殊的类成员函数，它定义将类类型值转变为其他类型值的转换。转换操作符在类定义体内声明，在保留字 operator 之后跟着转换的目标类型。转换函数又称类型强制转换成员函数，它是类中的一个非静态成员函数。它的定义格式如下：

代码如下:

　　　class <类型说明符1>

　　　　{

　　　　　public:

　　　　　　operator <类型说明符2>();

　　　　　　…

　　　　}

这个转换函数定义了由<类型说明符1>到<类型说明符2>之间的映射关系。可见，转换函数是用来将一种类型的数据转换成为另一种类型。

1.operator用于类型转换函数：

类型转换函数的特征：

1）型转换函数定义在源类中；

2）须由 operator 修饰，函数名称是目标类型名或目标类名；

3）函数没有参数，没有返回值，但是有return 语句，在return语句中返回目标类型数据或调用目标类的构造函数。

类型转换函数主要有两类：

1）对象向基本数据类型转换：

代码如下:

#include<iostream>

#include<string>

using namespace std;

class D{

public:

D(double d):d_(d) {}

operator int() const{

std::cout<<"(int)d called!"<<std::endl;

return static_cast<int>(d_);

}

private:

double d_;

};

int add(int a,int b){

return a+b;

}

int main(){

D d1=1.1;

D d2=2.2;

std::cout<<add(d1,d2)<<std::endl;

system("pause");

return 0;

}

结果：

可见在add(d1,d2)函数调用时隐性地调用了operator int() const 函数。

2）对象向不同类的对象的转换：

代码如下:

#include<iostream>

class X;

class A

{

public:

A(int num=0):dat(num) {}

A(const X& rhs):dat(rhs) {}

operator int() {return dat;}

private:

int dat;

};

class X

{

public:

X(int num=0):dat(num) {}

operator int() {return dat;}

operator A(){

A temp=dat;

return temp;

}

private:

int dat;

};

int main()

{

X stuff=37;

A more=0;

int hold;

hold=stuff;

std::cout<<hold<<std::endl;

more=stuff;

std::cout<<more<<std::endl;

return 0;

}

上面这个程序中X类通过“operator A()”类型转换来实现将X类型对象转换成A类型。

二、operator 重载圆括号

[cpp]
 include <iostream>  
 using namespace std;  
 class Time{  
     int hour;  
     int minute;  
     int second;  
 public:  
     Time( int h=0, int m=0, int s=0 )  
     {  
         operator()( h, m, s );  
     }  
     //版本0，返回时间表示的秒数  
     int operator()()  
     {  
         return hour*3600+minute*60+second;  
     }  
     //版本1，设置为整点  
     void operator()( int h )  
     {  
         operator()( h, 0, 0 );  
     }  
     //版本2，设置整小时和分钟  
     void operator()( int h, int m )  
     {  
         operator()( h, m, 0 );  
     }  
     //版本3，设置时分秒  
     void operator()( int h, int m, int s )  
     {  
         hour = h;  
         minute = m;  
         second = s;  
     }  
     friend ostream& operator<<( ostream& os, const Time& ct )  
     {  
         os << ct.hour << ';:';;  
         if( ct.minute<10 )  
             os << ';0';;  
         os << ct.minute << ';:';;  
         if( ct.second<10 )  
             os << ';0';;  
         os << ct.second;  
         return os;  
     }  
 };  
 int main()  
 {  
     Time t;  
     cout << t << endl;  
     t( 9 );//调用版本1  
     cout << t << endl;  
     t( 7, 30 );//调用版本2  
     cout << t << endl;  
     t( 0, 10, 20 );//调用版本3  
     cout << t << endl;  
     cout << t() << endl;//调用版本0  
     return 0;  
 }  

三、重载解引用

[cpp]
 T& operator*() const  
     {  
         if(!_ptr)  
         {  
             throwNullHandleException(__FILE__, __LINE__);             
         }  
   
         return *_ptr;  
     }  

四、重载->

[cpp]
 #include <iostream>  
 using namespace std;  
   
 class A{  
 public:  
     void action(){  
         cout << "Action in class A!" << endl;  
     }  
 };  
   
 class B{  
     A a;  
 public:  
     A* operator->(){  
         return &a;  
     }  
     void action(){  
         cout << "Action in class B!" << endl;  
     }  
 };  
   
 class C{  
     B b;  
 public:  
     B operator->(){  
         return b;  
     }  
     void action(){  
         cout << "Action in class C!" << endl;  
     }  
 };  
   
 int main(int argc, char *argv[])  
 {  
     C* pc = new C;  
     pc->action();  
     C c;  
     c->action();   
     getchar();  
     return 0;  
 }  

上面代码输出结果是：

Action in class C!

Action in class A!

c是对象，c后面的箭头操作符使用的是重载箭头操作符，即调用类C的operator->()成员函数。此时返回的是类B的对象，所以调用类B的operator->()成员函数，B的operator->()返回的是指针，所以现在可以使用内置箭头操作符了。对B的operator->()返回的指针进行解引用，然后调用解引用后的对象的成员函数action，此时调用的就是类A的action()。这里存在一个递归调用operator->()的过程，最后再使用一次内置含义的箭头操作符。

转载地址：http://drkfi.baihongyu.com/

你可能感兴趣的文章

JS操作SELECT表单大全，赋默认值，取值，增，删等

查看>>

浅谈BigDecimal类在电子商务中至关重要的地位!

查看>>

输出的数字的格式DecimalFormat的方法用途