Ｃ＋＋中Operator类型强制转换成员函数

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

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

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

类型转换函数的特征：

1） 型转换函数定义在源类中； 
2） 须由 operator 修饰，函数名称是目标类型名或目标类名； 
3） 函数没有参数，没有返回值，但是有return 语句，在return语句中返回目标类型数据或调用目标类的构造函数。

类型转换函数主要有两类： 
1） 对象向基本数据类型转换：

[cpp]  view plain copy print ?

1. #include"stdafx.h"  
2. #include <iostream>  
3. #include<string>  
4. using namespace std;  
5. class D {  
6.   public:  
7.      D(double d) : d_(d) {}  
8.    
9.      /* “(int)D”类型转换:将类型D转换成int */  
10.      operator int() const {  
11.          std::cout << "(int)d called!" << std::endl;  
12.          return static_cast<int>(d_);  
13.      }  
14.    
15.   private:  
16.      double d_;  
17.  };  
18.    
19.  int add(int a, int b) {  
20.      return a + b;  
21.  }  
22.    
23.   int main() {  
24.      D d1 = 1.1;  
25.      D d2 = 2.2;  
26.      std::cout << add(d1, d2) << std::endl;  
27.    
28.      system("pause");  
29.      return 0;  
30.  }  

在26行执行add(d1,d2)函数时“(int)D”类型转换函数将被自动调用，程序运行的输出为：

(int)d called!
(int)d called!
3

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

[cpp]  view plain copy print ?

1. #include <iostream>  
2.    
3.   class A  
4.  {  
5.   public:  
6.      A(int num = 0) : dat(num) {}  
7.        
8.      /* "(int)a"类型转换 */  
9.      operator int() { return dat; }  
10.    
11.   private:  
12.      int dat;  
13.  };  
14.    
15.    
16.   class X  
17.  {  
18.   public:  
19.      X(int num = 0) : dat(num) {}  
20.    
21.      /* "(int)a"类型转换 */  
22.      operator int() { return dat; }  
23.    
24.      /* "(A)a"类型转换 */  
25.      operator A() {  
26.          A temp = dat;  
27.          return temp;  
28.      }  
29.    
30.   private:  
31.      int dat;  
32.  };  
33.    
34.    
35.  int main()  
36.  {  
37.      X stuff = 37;  
38.      A more = 0;  
39.      int hold;  
40.    
41.      hold = stuff;    // convert X::stuff to int  
42.      std::cout << hold << std::endl;  
43.    
44.      more = stuff;    // convert X::stuff to A::more  
45.      std::cout << more << std::endl;        // convert A::more to int  
46.    
47.      return 0;  
48.  }  

上面这个程序中X类通过“operator A()”类型转换来实现将X类型对象转换成A类型，这种方式需要先创建一个临时A对象再用它去赋值目标对象；更好的方式是为A类增加一个构造函数：

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

同时，请注意上面程序的第45行more的类型在调用std::cout时被隐式地转成了int！

2． operator 用于操作符重载：

操作符重载的概念：

将现有操作符与一个成员函数相关联，并将该操作符与其成员对象（操作数）一起使用。

注意事项：

1） 重载不能改变操作符的基本功能，以及该操作符的优先级顺序。

2） 重载不应改变操作符的本来含义。

3） 只能对已有的操作符进行重载，而不能重载新符号。

4） 操作符重载只对类可用。

5） 以下运算符不能被重载：

. 原点操作符（成员访问符）

* 指向成员的指针

:: 作用域解析符

? : 问号条件运算符

sizeof 操作数的字节数

操作符函数的一般格式：

return_type operator op(argument list);

return_type：返回类型（要得到什么）

op：要重载的操作符

argument list：参数列表（操作数有哪些）

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3.    
4. class employee  
5. {  
6.        int salary;  
7. public:  
8.        void setSalary(int s)  
9.        {  
10.               salary=s;  
11.        }  
12.        void getSalary()  
13.        {  
14.               cout<<salary<<endl;  
15.        }  
16.        bool operator >(const employee & e)//重载大于号操作符  
17.        {  
18.               if(salary > e.salary)  
19.                      return true;  
20.               else  
21.                      return false;  
22.        }  
23. };  
24. void main()  
25. {  
26.        employee emp1,emp2;  
27.        emp1.setSalary(1000);  
28.        emp2.setSalary(2000);  
29.        if (emp1 > emp2)  
30.        {  
31.               cout<<"emp1比emp2工资高"<<endl;  
32.        }  
33.        else  
34.        {  
35.               cout<<"emlp1没有emp2工资高"<<endl;  
36.        }  
37. }