Conversion Operators

最新推荐文章于 2022-10-19 19:02:40 发布

原创最新推荐文章于 2022-10-19 19:02:40 发布 · 261 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#primitive #printing #function #compiler #library #class

C++ 专栏收录该内容

8 篇文章

订阅专栏

本文通过一个复数类的实例介绍了C++中的转换运算符。这些运算符允许将一个类类型隐式转换为另一个类型，如从复数类转换为双精度浮点数类型。文章展示了如何实现这一功能，并提供了完整的代码示例。

In C++, the programmer abstracts real world objects using classes as concrete types. Sometimes it is required to convert one concrete type to another concrete type or primitive type implicitly. Conversion operators play smart role in such situations.

For example consider the following class

#include <iostream>
#include <cmath>
 
using namespace std;
 
class Complex
{
private:
    double real;
    double imag;
 
public:
    // Default constructor
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i)
    {}
 
    // magnitude : usual function style
    double mag()
    {
        return getMag();
    }
 
    // magnitude : conversion operator
    operator double ()
    {
        return getMag();
    }
 
private:
    // class helper to get magnitude
    double getMag()
    {
        return sqrt(real * real + imag * imag);
    }
};
 
int main()
{
    // a Complex object
    Complex com(3.0, 4.0);
 
    // print magnitude
    cout << com.mag() << endl;
    // same can be done like this
    cout << com << endl;
}

We are printing the magnitude of Complex object in two different ways.

Note that usage of such smart (over smart ?) techniques are discouraged. The compiler will have more control in calling an appropriate function based on type, rather than what the programmer expects. It will be good practice to use other techniques like class/object specific member function (or making use of C++ Variant class) to perform such conversions. At some places, for example in making compatible calls with existing C library, these are unavoidable.