C++类型转换操作符（type conversion operator）

类型转换操作符（type conversion operator）是一种特殊的类成员函数，它定义将类类型值转变为其他类型值的转换。转换操作符在类定义体内声明，在保留字 operator 之后跟着转换的目标类型。boost::ref和boost::cref就使用到了类型转换操作符。

 

函数原型 

T1::operator T2() [const];　　　//T1的成员函数，"(T2)a"类型转换

1. 转换函数必须是成员函数，不能指定返回类型，并且形参表必须为空；返回值是隐含的，返回值是与转换的类型相同的，即为上面原型中的T2；

2. T2表示内置类型名（built-in type）、类类型名（class type）或由类型别名（typedef）定义的名字；对任何可作为函数返回类型的类型（除了 void 之外）都可以定义转换函数，一般而言，不允许转换为数组或函数类型，转换为指针类型（数据和函数指针）以及引用类型是可以的；

3. 转换函数一般不应该改变被转换的对象，因此转换操作符通常应定义为 const 成员；

4. 支持继承，可以为虚函数；

5. 只要存在转换，编译器将在可以使用内置转换的地方自动调用它；

 

 

先通过一个简单的例子来说明如何使用类型转换操作符

#include <iostream>

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

    /* “(int)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;

    return 0;
}

 

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

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

 

类型转换操作符 vs 类型转换构造函数（conversion constructor）

有时候使用conversion constructor就能实现类型转换，这种方式效率更高而且也更直观，下面举例说明：

#include <iostream>

 class A
{
 public:
    A(int num = 0) : dat(num) {}
    
    /* "(int)a"类型转换 */
    operator int() { return dat; }

 private:
    int dat;
};


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

    /* "(int)a"类型转换 */
    operator int() { return dat; }

    /* "(A)a"类型转换 */
    operator A() {
        A temp = dat;
        return temp;
    }

 private:
    int dat;
};


int main()
{
    X stuff = 37;
    A more = 0;
    int hold;

    hold = stuff;    // convert X::stuff to int
    std::cout << hold << std::endl;

    more = stuff;    // convert X::stuff to A::more
    std::cout << more << std::endl;        // convert A::more to int

    return 0;
}

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

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

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

 

一个简单boost::ref实现

通过重载type conversion operator，我们就可以自己实现一个简版的boost::ref。

#include <iostream>

template <class T>
 class RefHolder
{
 public:
    RefHolder(T& ref) : ref_(ref) {}

    /* “(T&)A”类型转换操作符 */
    operator T& () const {
        return ref_;
    }

 private:
     T& ref_;
};


template <class T>
inline RefHolder<T> ByRef(T& t) {
    return RefHolder<T>(t);
}

 int inc(int& num) {
    num++;
    return num;
}


 int main() {
    int n = 1;
    std::cout << inc(ByRef(n)) << std::endl;    //RefHolder<int>被转换成了"int&"类型
     
    return 0;
}
 

 

 

参考文章：

1. Wiki - Operators in C and C++

2. Cast operator overload

3. Overloading the typecast operator

4. Generic<Programming>: Change the Way You Write Exception-Safe Code Forever

5. C++ Primer - 14.9 Conversions and Class Types