conversion function(转换函数)

Posted on Edited on In , , Changyan: Symbols count in article: 1.8k Reading time ≈ 2 mins.
  • 转换函数
    1
    2
    3
    operator double() const{ //表示在需要转换为double时调用这个函数,将对象转换为double 返回值不需要编写
                return (double)(m_numertor / m_denominator)
            }

    转换函数

    将对象转换出去

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Fraction
    {
        public:
             Fraction(int num,int den=1):m_numertor(num),m_denominator(den){} // one argument(只需要一个实参就够了),two paramenter。
            operator double() const{ //表示在需要转换为double时调用这个函数,可以写多个
                return (double)(m_numertor / m_denominator)
            }
        private:
            int m_numertor;
            int m_denominator;
    }
1
2
Fraction f(3,5);
double d=4+f;

编译器会做如下操作:

  1. 查找全局函数+,并且第一个参数是int 或者double 第二个参数是Fraction
  2. 尝试将Fraction 转换为double；这个存在，既可以编译通过
  3. 将4 转换为Fraction

    将其他的转换为特定类型

non-explicit-one-argument 构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Fraction
{
    public:
    //non explicit 函数
        Fraction(int num,int den=1):m_numertor(num),m_denominator(den){} // one argument(只需要一个实参就够了),two paramenter。
        operator + (const Fraction& f){ //表示在需要转换为double时调用这个函数,可以写多个
            return Fraction(f);
        }
    private:
        int m_numertor;
        int m_denominator;
}
Fraction f(3,5);
Fraction d=4+f;//这个与设计不同，设计的在d=f+4 时调用

冲突情况

  • 编译失败
    • 存在多个情况，
      • 将4转换为Fraction ，相加
      • 将Fraction 转换为double，得到double再转换为Fraction的情况
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        class Fraction
        {
            public:
            //non explicit 函数
                Fraction(int num,int den=1):m_numertor(num),m_denominator(den){} 
                operator double() const{ 
                    return (double)(m_numertor / m_denominator)
                }
                operator + (const Fraction& f){ 
                    return Fraction(f);
                }
            private:
                int m_numertor;
                int m_denominator;
        }
        Fraction f(3,5);
        Fraction d=f+4; //Error ambiguous

        解决冲突

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        class Fraction
        {
            public:
            //explicit 函数，构造函数前面
             explicit   Fraction(int num,int den=1):m_numertor(num),m_denominator(den){} 
                operator double() const{ 
                    return (double)(m_numertor / m_denominator)
                }
                operator + (const Fraction& f){ 
                    return Fraction(f);
                }
            private:
                int m_numertor;
                int m_denominator;
        }
        Fraction f(3,5);
        Fraction d=f+4; //Error 4 不会默认转化为 Fraction，因为explicit，所以编译失败