C++面向对象高级编程(六)转换函数与non-explicit one argument ctor

技术在于交流、沟通，转载请注明出处并保持作品的完整性。

1.conversion function 转换函数

    //1.转换函数
    //conversion function
    //只要你认为合理 你可以任意写转换函数
    class Fraction
    {
    public:
        Fraction(int num, int  den = 1):m_numerator(num),m_denominator(den){}
        
        operator double() const //注意看 没有返回类型,这个编译器会帮做,且防止我们声明错误 函数名就是返回类型
        {
            return ((double)m_numerator / m_denominator) ;//见下面自动转化规则
        }
    private:
        int m_numerator;
        int m_denominator;
    };
    
    int main(int argc, const char * argv[]) {
        
        Fraction f(3,5);
        double d = 4 + f;  //先找全局函数 operator+ , 发现没有,再去找  发现在 Fraction内找到了
        cout<< d << endl;
        cout<<sizeof(double) << endl;
        
        return 0;
    }

自动转换遵循以下规则：

1)若参与运算量的类型不同，则先转换成同一类型，然后进行运算。

2)转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。

a.若两种类型的字节数不同，转换成字节数高的类型

b.若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型

3)所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

4)char型和short型参与运算时，必须先转换成int型。

5)在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

例如：

上面的  return ((double)m_numerator / m_denominator) ;

如果声明成这样 (double) (m_numerator / m_denominator) 会执行int类型的除法运算

所以要先将两个int型参数的一个转换成double型参数即可

---

2.non-explicit one argument ctor

explicit的作用,防止隐式转换,一般作用于带参数的构造函数

class Fraction
{
public:
    Fraction(int num, int  den = 1):m_numerator(num),m_denominator(den){} //
    
    Fraction operator+(const Fraction & f)
    {
        cout << f.m_numerator<<endl;
        return f;
    }
private:
    int m_numerator;
    int m_denominator;
};
    
int main()
{
    Fraction f(3,5);
    Fraction d = f + 4;//调用时会使 4 隐式转换成 Fraction //调用的过程也是先去找f的operator+函数 找到了 调用
    return 0;
}

输出结果

Fraction d = f + 4; 这个函数的意义是 f调用operator+ 参数为4 

而接受端

你会发现4被隐式转换成 Fraction

Fraction operator+(const Fraction & f){...}

参数4就被隐式转换成Fraction

那么加上 explicit

class Fraction
{
public:
    explicit Fraction(int num, int  den = 1):m_numerator(num),m_denominator(den){} //
    
    Fraction operator+(const Fraction & f)
    {
        cout << f.m_numerator<<endl;
        return f;
    }
private:
    int m_numerator;
    int m_denominator;
};

调用端

 

---

上面我提到两次 调用过程 那么如果将operator+  与 operator double() 连用的话会发生什么情况

class Fraction
{
public:
    /*explicit*/ Fraction(int num, int  den = 1):m_numerator(num),m_denominator(den){} //
    
    Fraction operator+(const Fraction & f)
    {
        cout << f.m_numerator<<endl;
        return f;
    }
    
    operator double() const //注意看 没有返回类型,这个编译器会帮做,且防止我们声明错误 函数名就是返回类型
    {
        return ((double)m_numerator / m_denominator) ;//见下面自动转化规则
    }
private:
    int m_numerator;
    int m_denominator;
};
    

编译会报错

参照<<侯捷 C++面向对象高级编程>>