c++语法：转换构造函数以及类型转换函数以及c++中的类型转换

operator type(){
    //TODO:
    return data;
}

#include <iostream>
using namespace std;
//复数类
class Complex{
public:
    Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }  //包含了转换构造函数
public:
    friend ostream & operator<<(ostream &out, Complex &c);
    friend Complex operator+(const Complex &c1, const Complex &c2);
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;  //实部
    double m_imag;  //虚部
};
//重载>>运算符
ostream & operator<<(ostream &out, Complex &c){
    out << c.m_real <<" + "<< c.m_imag <<"i";;
    return out;
}
//重载+运算符
Complex operator+(const Complex &c1, const Complex &c2){
    Complex c;
    c.m_real = c1.m_real + c2.m_real;
    c.m_imag = c1.m_imag + c2.m_imag;
    return c;
}
int main(){
    Complex c1(24.6, 100);
    double f = c1;  //①正确，调用类型转换函数
    c1 = 78.4;  //②正确，调用转换构造函数
    f = 12.5 + c1;  //③错误，产生二义性
    Complex c2 = c1 + 46.7;  //④错误，产生二义性
    return 0;
}

 1 #include <iostream>
 2 using namespace std;
 3 //复数类
 4 class Complex{
 5 public:  //构造函数
 6     Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }  //包含了转换构造函数
 7 public:  //运算符重载
 8     //以全局函数的形式重载
 9     friend ostream & operator<<(ostream &out, Complex &c);
10     friend istream & operator>>(istream &in, Complex &c);
11     friend Complex operator+(const Complex &c1, const Complex &c2);
12     friend bool operator==(const Complex &c1, const Complex &c2);
13     friend bool operator!=(const Complex &c1, const Complex &c2);
14     //以成员函数的形式重载
15     Complex & operator+=(const Complex &c);
16 public:  //成员函数
17     double real() const{ return m_real; }
18     double imag() const{ return m_imag; }
19 private:
20     double m_real;  //实部
21     double m_imag;  //虚部
22 };
23 //重载>>运算符
24 ostream & operator<<(ostream &out, Complex &c){
25     out << c.m_real <<" + "<< c.m_imag <<"i";;
26     return out;
27 }
28 //重载<<运算符
29 istream & operator>>(istream &in, Complex &c){
30     in >> c.m_real >> c.m_imag;
31     return in;
32 }
33 //重载+运算符
34 Complex operator+(const Complex &c1, const Complex &c2){
35     Complex c;
36     c.m_real = c1.m_real + c2.m_real;
37     c.m_imag = c1.m_imag + c2.m_imag;
38     return c;
39 }
40 //重载+=运算符
41 Complex & Complex::operator+=(const Complex &c){
42     this->m_real += c.m_real;
43     this->m_imag += c.m_imag;
44     return *this;
45 }
46 //重载==运算符
47 bool operator==(const Complex &c1, const Complex &c2){
48     if( c1.m_real == c2.m_real && c1.m_imag == c2.m_imag ){
49         return true;
50     }else{
51         return false;
52     }
53 }
54 //重载!=运算符
55 bool operator!=(const Complex &c1, const Complex &c2){
56     if( c1.m_real != c2.m_real || c1.m_imag != c2.m_imag ){
57         return true;
58     }else{
59         return false;
60     }
61 }
62 int main(){
63     Complex c1(12, 60);
64     cout<<"c1 = "<<c1<<endl;
65     //先调用转换构造函数将 22.8 转换为 Complex 类型，再调用重载过的 + 运算符
66     Complex c2 = c1 + 22.8;
67     cout<<"c2 = "<<c2<<endl;
68     //同上
69     Complex c3 = 8.3 + c1;
70     cout<<"c3 = "<<c3<<endl;
71     //先调用转换构造函数将 73 转换为 Complex 类型，再调用重载过的 += 运算符
72     Complex c4(4, 19);
73     c4 += 73;
74     cout<<"c4 = "<<c4<<endl;
75     //调用重载过的 += 运算符
76     Complex c5(14.6, 26.2);
77     c5 += c1;
78     cout<<"c5 = "<<c5<<endl;
79    
80     //调用重载过的 == 运算符
81     if(c1 == c2){
82         cout<<"c1 == c2"<<endl;
83     }else{
84         cout<<"c1 != c2"<<endl;
85     }
86    
87     //先调用转换构造函数将 77 转换为 Complex 类型，再调用重载过的 != 运算符
88     if(c4 != 77){
89         cout<<"c4 != 77"<<endl;
90     }else{
91         cout<<"c4 == 77"<<endl;
92     }
93     //将 Complex 转换为 double，没有调用类型转换函数，而是调用了 real() 这个普通的成员函数
94     double f = c5.real();
95     cout<<"f = "<<f<<endl;
96    
97     return 0;
98 }