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

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

      • C语言中的类型转换
      • 普通类型到类类型的转换
      • 类类型到普通类型的转换
      • 类类型之间的转换
      • Qt的类型转换函数

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()的公有成员函数来代替类型转换函数。这样就不会默认调用类型转换函数了。

你可能感兴趣的:(C++)