转换构造函数

Complex ( double d)

{

   real =r;

   image =0;

}

其作用是将double 类型的参数d转换成Complex类的对象。

转换构造函数：将一个其它类型的数据转换成一个类对象。只能有一个参数。

如：

c=c1+Complex(2.5);

============================

类型转换函数：

           将一个类对象转换成另一个类型数据。只能是类的成员函数。

operator double()

{

    return real;

}

 

比如：

c1=c2+d1

编译系统是怎么处理的了？先寻找有无对"+"的重载，当发现有operator+函数时，判断是否是友员函数还是类的成员函数，且对double参数的重载。没有的话，就再次寻找是否有operate double 类型转换函数来把c2转换成double.

没有的话，再次寻找有无转换构造函数，则会建立一个临时complex类对象，在调用operator+函数来实现类相加。

：c1=c2+Complex(d1).

=====================================

 

d=2.3+c3;：当发现没有operator+函数时，则寻找类型转换函数operator double，把类c3转换成double。

d=c2+2.3;

 d= c1+c2; 当发现有operator+函数时，先把2个类相加，然后在寻找类型转换函数operator double，把类Complex(c3+c2)转换成double。

 

c3=c1+2.3;//当发现有operator+函数时，先去寻找转换构造函数Complex(doubel r){real=r},把c3=c1+Complex(2.3);

c3=2.3+c1；//同样先转换operator+(2.3,c1),发现有Complex(2.3),则operator(Complex(2.3),c1)

========================================

注：定义类型转换，可以减少 operator+ ... 运算符重载函数的数量。不用专门定义对应的：

friend Complex operator+(double, Complex &);

Complex operator+(double);

 

 -------------------------------

#include<iostream>
using namespace std;
class Complex
{
 public:
 Complex(){real=0;image=0;}
 Complex(double r){real =r;}
 Complex(double r,double i):real(r),image(i){}
 void display();
 friend Complex operator+(Complex &,Complex &);
 operator double()
 {
  return real;
 }
 private:
 double real,image;
};
void Complex::display()
{
 cout<<"real:"<<real<<" image:"<<image<<endl; 
}

Complex operator+(Complex &c1,Complex &c2)
{
 return Complex(c1.real+c2.real,c1.image+c2.image);  
}

int main()
{
 Complex c1(12.1,1),c2(1.1,2.3),c3;
 c3=c1+c2;
 c3.display();
 
 double d;
 d=2.3+c3;
 cout<<"d:"<<d<<endl;
 d= c1+c2;
 cout<<"d:"<<d<<endl;
 c3=c1+2.3;
 c3.display();
 return 0;
}