zoukankan      html  css  js  c++  java
  • conversion function——转换函数

    类型转换函数 与 explicit关键字

    1.类型转换函数

    C++中,可以使用构造函数将一个指定类型的数据转换为类的对象,也可以使用类型转换函数 (type conversion function)将一个类对象转换为其他类型的数据。例:

    分数(Fraction)类

     1 #include <iostream>
     2 
     3 using namespace std;
     4 
     5 class Fraction
     6 {
     7 public:
     8     Fraction(int num, int den = 1) :m_numberator(num), m_denominator(den) {}
     9 
    10     operator double() const //转换函数
    11     {
    12         return (double)m_numberator / m_denominator;
    13     }
    14 
    15 private:
    16     int m_numberator;  //分子
    17     int m_denominator; //分母
    18 };
    19 
    20 int main()
    21 {
    22     Fraction f(3,4);
    23     double d = 3 + f;   //调用 opertor double() 将f转化为double
    24     cout << d << endl;
    25     return 0;
    26 }

    f是一个Fraction类型的变量,因此不能直接与3相加,于是编译器会到分数类中寻找,找到了operator double函数,该函数可以将类型对象转换为一个浮点类型的变量。因此该函数就是我们所说的类型转换函数(type conversion function)。

    转换函数的一般形式:

    1 operator 类型名称() const
    2 {
    3         // 实现转换      
    4 }
    1. 必须是类的成员函数
    2. 无返回类型
    3. 形参列表为空
    4. 最好为const

    2.explicit关键字

    也可以通过重载+double类型转换为Fraction类类型。因此该类的代码如下:

     1 #include <iostream>
     2 
     3 class Fraction
     4 {
     5 public:
     6     Fraction(int num, int den = 1) : m_numberator(num), m_denominator(den) {}
     7 
     8     Fraction operator+(const Fraction &f)
     9     {
    10         return Fraction(this->m_numberator + f.m_numberator, this->m_denominator + f.m_denominator);
    11     }
    12 
    13 private:
    14     int m_numberator;  //分子
    15     int m_denominator; //分母
    16 };
    17 
    18 int main()
    19 {
    20     Fraction f(3, 4);
    21     Fraction d = f + 4; //调用 non-explicit-one-argument ctor 将4转化为Fraction
    22     return 0;
    23 }

    但是如果同时存在类型转换函数,就存在了二义性。例:

     1 #include <iostream>
     2 
     3 class Fraction
     4 {
     5 public:
     6     Fraction(int num, int den = 1) : m_numberator(num), m_denominator(den) {}
     7     
     8     operator double() const
     9     {
    10         return (double)m_numberator / m_denominator;
    11     }
    12 
    13     Fraction operator+(const Fraction &f)
    14     {
    15         return Fraction(this->m_numberator + f.m_numberator, this->m_denominator + f.m_denominator);
    16     }
    17 
    18 private:
    19     int m_numberator;  //分子
    20     int m_denominator; //分母
    21 };
    22 
    23 int main()
    24 {
    25     Fraction f(3, 4);
    26     double d = f + 4; //二义性
    27     return 0;
    28 }
    • f对象可以通过类型转换函数将类类型转换为double类型,然后加上4赋值给d
    • 4也可以通过构造函数转换为Fraction类型,然后两个类类型相加,又可以通过类型转换函数转换为double类型

    解决的办法就是,使用explicit关键字的限制,使用方法也有两种:

    • 直接在构造函数前加上explicit关键字,防止double类型的变量隐式的转换为类类型。
    • 在转换构造函数operator double前加上explicit关键字,表示只有显示的将类类型转换为double类型时才调用该函数,例如:double d = static_cast<double>(f) + 4。
  • 相关阅读:
    第二章—数据类型字符串str
    第二章—数据类型列表list
    第二章—编码
    第二章——进制
    ConfigParser模块
    描述符__get__,__set__,__delete__
    面向对象 ,特殊成员和魔法方法
    异常处理
    反射
    绑定方法与非绑定方法
  • 原文地址:https://www.cnblogs.com/vlyf/p/11688030.html
Copyright © 2011-2022 走看看