转换函数conversion function

类转换分为两个角度

• 转换自身为其他类型
• 把其他类型转换为自身

Example:

这里我们可以将b转换为class xxx 的类型(方式2),也可以将me转换为double,然后再讲结果转换为double

class xxx me;

double  b=0;

class a=me+b;

double a2=me+b;

 
 

重载转换函数(转换自身到其他类型)

重载转换函数的语法格式如下,一般不用写返回类型,因为你转换成一个类型,返回值一般就是那个类型了

operator Type_name() 

 
 

Example: 这里重载了double 运算,因为一般的转换我们不会去更改对象的本身,所以函数后面加上 const

#include <iostream>

using namespace std;

class Fraction

{

public:

    Fraction(int num,int den=1):m_numerator(num),m_denominator(den){}

    operator double() const

    {

cout << "double() run"<<endl;

        return (double)((double)m_numerator/m_denominator);

    }

private:

    int m_numerator;

    int m_denominator;

};

int main()

{

    Fraction f(3,5);

    double d=f+4;

    cout << d << endl;

    return 0;

}

这里的 double d= f+4; 中,将f转换为double,然后执行

 
 

一个注意点

// double
d=f+4; 把f转换为double

// Fraction d=f+4;

//1.把f转换为一个double ,因为先打印了 double()

//2.把结果+4也就是一个double转换为一个Fraction ,这里会调用一个参数的构造函数,我们可以将构造函数改为两个参数试试

// 2.1
Fraction(int num,int den):m_numerator(num),m_denominator(den)

// 2.2
这里就会提示
error C2440: "初始化": 无法从"double"转换为"Fraction"

  

 
 

转换构造函数(转换其他到自身)

什么时候能转换其他到自身? 一般就是重载了 一般的运算符隐式转换或者使用强制转换,比如我们定义了一个类f_class,如果重载操作符+,那么f_class+xxx的时候,xxx可以被重载到+的操作函数,如果此时还有一个实参的构造函数,那么就能执行隐式转换,这个构造函数也称为转换构造函数

注意: 一个函数如果有多个m个paremeters,m-1个默认参数的参数,也就是一个argument,也是转换构造函数

 
 

Example: 重载了+,然后有一个转换构造函数

#include <iostream>

using namespace std;

class Fraction

{

public:

    Fraction(int num,int den=1):m_numerator(num),m_denominator(den){}

    /*

    operator double() const

    {

        return (double)((double)m_numerator/m_denominator);

    }

    */

    Fraction operator +(const Fraction& elem)

    {

        return Fraction(this->m_numerator+elem.m_numerator,this->m_denominator+elem.m_denominator);

    }

    int m_numerator;

    int m_denominator;

};

// 重载一个<< 方便打印这个类Fraction

ostream& operator << (ostream &o,const Fraction&elem)

{

    o << "m_numerator= "<<elem.m_numerator

      << " m_denominator= "<<elem.m_denominator << endl;

    o << "double value= "<< (double)elem.m_numerator/elem.m_denominator<< endl;

    return o;

}

int main()

{

    Fraction f(3,5);

// +重载

// 无法支持 double d=f+4; 因为f+4返回为Franction,并没有办法转换为double

// Fraction d=f+4;

// 1. 4转换为Franction,根据只有一个实参的构造函数

// 2. 加法

 
 

    Fraction d=f+4;

    cout << d << endl;

    return 0;

}

 

这里 Fraction d=f+4; 我们可以找到4转化为fraction的方式,所以执行了,不能使用double d=f+4; 因为f+4返回为Franction,并没有办法转换为double

  

 
 

 
 

Explicit之同时存在以及歧义

如果同时存在上述两种形式,则会引发歧义,这两种转换没有谁优先的概念

error C2666: "Fraction::operator +": 2 个重载有相似的转换 ambiguous

也就是打开上面的注释的地方

使用关键字 Explicit 表示构造函数不再支持隐式的转换了

在上述例子中也就是无法将4转换为Fraction,我们需要显示指定转换才可以

; // ok

 
 

也可以同时使用double和显示的构造转换了

;

Fraction
;

#include <iostream>

using namespace std;

class Fraction

{

public:

):m_numerator(num),m_denominator(den)

{

cout<<"ctor run: m_numerator="<<m_numerator<<" m_denominator=" << m_denominator <<endl;

}

 
 

operator double() const

{

cout << "double() run"<<endl;

return (double)((double)m_numerator/m_denominator);

}

 
 

Fraction operator +(const Fraction& elem)

{

cout << "+() run"<<endl;

return Fraction(this->m_numerator+elem.m_numerator,this->m_denominator+elem.m_denominator);

}

 
 

int m_numerator;

int m_denominator;

};

 
 

// 重载一个<< 方便打印这个类Fraction

ostream& operator << (ostream &o,const Fraction&elem)

{

o << "m_numerator= "<<elem.m_numerator

<< " m_denominator= "<<elem.m_denominator << endl;

o << "double value= "<< (double)elem.m_numerator/elem.m_denominator<< endl;

return o;

}

 
 

int main()

{

,);

// double 转换f为double

// Fraction d=f+4;

//1.把f转换为一个double ,因为先打印了 double()

//2.把结果+4也就是一个double转换为一个Fraction ,这里会调用一个参数的构造函数,我们可以将构造函数改为两个参数试试

// 2.1
Fraction(int num,int den):m_numerator(num),m_denominator(den)

// 2.2
这里就会提示
error C2440: "初始化": 无法从"double"转换为"Fraction"

 
 

// +重载

// 无法支持 double d=f+4; 因为f+4返回为Franction,并没有办法转换为double

// Fraction d=f+4;

// 1. 4转换为Franction,根据只有一个实参的构造函数

// 2. 加法

 
 

double
;

Fraction
;

 
 

cout << d << endl;

;

}