类型转换函数 与 explicit关键字

1.类型转换函数

在C++中，可以使用构造函数将一个指定类型的数据转换为类的对象，也可以使用类型转换函数 (type conversion function)将一个类对象转换为其他类型的数据。例：

分数(Fraction)类

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class Fraction
 6 {
 7 public:
 8     Fraction(int num, int den = 1) :m_numberator(num), m_denominator(den) {}
 9 
10     operator double() const //转换函数
11     {
12         return (double)m_numberator / m_denominator;
13     }
14 
15 private:
16     int m_numberator;  //分子
17     int m_denominator; //分母
18 };
19 
20 int main()
21 {
22     Fraction f(3,4);
23     double d = 3 + f;   //调用 opertor double() 将f转化为double
24     cout << d << endl;
25     return 0;
26 }

f是一个Fraction类型的变量，因此不能直接与3相加，于是编译器会到分数类中寻找，找到了operator double函数，该函数可以将类型对象转换为一个浮点类型的变量。因此该函数就是我们所说的类型转换函数(type conversion function)。

转换函数的一般形式：

1 operator 类型名称() const
2 {
3         // 实现转换      
4 }

1. 必须是类的成员函数
2. 无返回类型
3. 形参列表为空
4. 最好为const

2.explicit关键字

也可以通过重载+将double类型转换为Fraction类类型。因此该类的代码如下：

 1 #include <iostream>
 2 
 3 class Fraction
 4 {
 5 public:
 6     Fraction(int num, int den = 1) : m_numberator(num), m_denominator(den) {}
 7 
 8     Fraction operator+(const Fraction &f)
 9     {
10         return Fraction(this->m_numberator + f.m_numberator, this->m_denominator + f.m_denominator);
11     }
12 
13 private:
14     int m_numberator;  //分子
15     int m_denominator; //分母
16 };
17 
18 int main()
19 {
20     Fraction f(3, 4);
21     Fraction d = f + 4; //调用 non-explicit-one-argument ctor 将4转化为Fraction
22     return 0;
23 }

但是如果同时存在类型转换函数,就存在了二义性。例：

 1 #include <iostream>
 2 
 3 class Fraction
 4 {
 5 public:
 6     Fraction(int num, int den = 1) : m_numberator(num), m_denominator(den) {}
 7     
 8     operator double() const
 9     {
10         return (double)m_numberator / m_denominator;
11     }
12 
13     Fraction operator+(const Fraction &f)
14     {
15         return Fraction(this->m_numberator + f.m_numberator, this->m_denominator + f.m_denominator);
16     }
17 
18 private:
19     int m_numberator;  //分子
20     int m_denominator; //分母
21 };
22 
23 int main()
24 {
25     Fraction f(3, 4);
26     double d = f + 4; //二义性
27     return 0;
28 }

• f对象可以通过类型转换函数将类类型转换为double类型，然后加上4赋值给d
• 4也可以通过构造函数转换为Fraction类型，然后两个类类型相加，又可以通过类型转换函数转换为double类型

解决的办法就是，使用explicit关键字的限制，使用方法也有两种：

• 直接在构造函数前加上explicit关键字，防止double类型的变量隐式的转换为类类型。
• 在转换构造函数operator double前加上explicit关键字，表示只有显示的将类类型转换为double类型时才调用该函数，例如：double d = static_cast<double>(f) + 4。