C++重载——类型转换运算符

本文参照于狄泰软件学院，唐佐林老师的——《C++深度剖析教程》

C语言中的类型转换

1. 标准数据类型之间会进行隐式类型安全转换
2. 转换规则如下：

问题：在C++中，普通类型与类类型之间能否进行类型转换？

普通类型到类类型的转换

转换构造函数(特殊的构造函数)
满足下列条件的构造函数称为转换构造函数：
1. 有且仅有一个参数
2. 参数是基本类型
3. 参数是其它类类型

示例代码：普通类型类类型

#include 
#include 

using namespace std;

class Test
{
    int mValue;
public:
    Test()
    {
        mValue = 0;
    }

    explicit Test(int i)
    {
        mValue = i;
    }

    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);

        return ret;
    }

    int value()
    {
        return mValue;
    }
};

int main()
{   
    Test t;

    Test t1;    
    t1 = 10;  //Error

    t = static_cast(5);    // t = Test(5);

    Test r;

    r = t + static_cast(10);   // r = t + Test(10);

    cout << r.value() << endl;

    return 0;
}

输出结果：15
输出结果如我们所想一样，可以进行隐式转换。但是我们想知道编译器是如何工作的。

编译器会尽力尝试让源码通过编译：例如有: Test t; t = 100;
1. 100这个立即数默认为int类型，怎么可能复制给t对象呢？现在就报错吗？
2. 不急，我看看有没有转换构造函数！OK，发现Test类中定义了Test(int i);
3. 可以进行转换，默认等价于: t = Test(100);

通过上面的行为我们可以发现，编译器尽力尝试的结果是隐式类型转换。而隐式类型转换会让程序以意想不到的方式进行工作，是工程中bug的重要来源之一。

问题：我们如何阻止编译器隐式类型转换呢？

C++为我们提供了explicit关键字杜绝编译器的转换尝试, 转换构造函数被explicit修饰时只能进行显示转换
如例程所示，当explicit修饰时，t1 = 10;这样的赋值方式编译器是不允许的，会报错。
而我们之所以需要阻止编译器默认转换类型的这个行为，除了防止bug以外，还有另外一个

原因就是：
r = t +10;这个表达式在不使用explicit时，是合法的。那么就与我们写的操作符重载函数的意义不相同。我们想传入的是一个类对象，结果一个int类型的也合法，这不符合我们的代码规范。

类类型到普通类型的转换

从上面的示例我们可以知道，普通类型可以强制类型转换为类类型，那么反过来，类类型可以转换为普通类型吗？
1. C++类中可以定义类型转换函数
类型转换函数用于将类对象转换为其它类型。函数原型为：operate Type();
2. 类型转换函数与转换构造函数具有同等的地位
3. 使得编译器有能力将对象转化为其它类型
4. 编译器能够隐式的使用类型转换函数

示例代码：类型转换函数初探

#include 
#include 

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator int ()
    {
        return mValue;
    }
};

int main()
{   
    Test t(100);
    int i = t;

    cout << "t.value() = " << t.value() << endl;
    cout << "i = " << i << endl;

    return 0;
}

输出结果：
t.value() = 100
i = 100
编译器具体的行为与普通类型转换到类类型相似。

类类型之间的转换

现在我们知道了，普通数据类型到类类型之间的转换时调用转换构造函数；而类类型到普通数据类型的转换是调用类型转换函数。

那么，类类型之间的相互转换又是怎么样的呢？
我们可以尝试使用转换构造函数和类型转换函数来验证一下，是否直接支持类类型之间的转换。

示例代码：类类型之间的转换

#include 
#include 

using namespace std;

class Value
{
public:
    Value()
    {
    }
    Value(Test& t)
    {
        cout << "explicit Value(Test& t)" << endl;
    }
};

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }

    operator Value()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }

};

int main()
{   
    Test t(100);
    Value v = t;

    return 0;
}

从输出结果我们可以发现：转换构造函数和类型转换函数发生冲突了，编译器不知道应该调用哪个函数。因此发生了错误。
当然我们可以使用explicit关键字抑制隐式的转换构造函数，让程序只调用类型转换函数。但是，我们无法抑制隐式的类型转换函数。

Qt的类型转换函数

问题：那么我们如何屏蔽类型转换函数呢？
我们可以参考Qt的实现方式，我们不使用类型转换函数，而是使用类的成员函数来代替类型转换函数。

示例代码：Qt的类型转换函数

#include 
#include 

int main()
{
    QString str = "";
    int i = 0;
    double d = 0;
    short s = 0;

    str = "-255";
    i = str.toInt();
    d = str.toDouble();
    s = str.toShort();

    qDebug() << "i = " << i << endl;
    qDebug() << "d = " << d << endl;
    qDebug() << "s = " << s << endl;

    return 0;
}

在Qt中，使用Type toType()的公有成员函数来代替类型转换函数。这样就不会默认调用类型转换函数了。