C++：类型转换

#include<iostream.h>
using namespace std;
class Complex{
  public:
    Complex(){};                //不带参数的构造函数 
    Complex(double r,double i)  //带两个参数的构造函数 
    {
     real = r;
     imag = i;
    }
    Complex(double r)           //转换构造函数
    {
     real = r;
     imag = 0;
    } 
    friend Complex operator+(Complex &a,Complex &b) //定义友元运算符+重载函数 
    {
      Complex temp;
      temp.real= a.real+b.real;
      temp.imag= a.imag+b.imag;
      return temp; 
    }
    void print(); 
  private:
    double real;
    double imag;
};
void Complex::print()
{
  cout<<real;
  if(imag>0) cout<<"+";
  if(imag!=0) cout<<imag<<"i\n";
} 
int main()
{
 Complex com1(1.1,2.2),com3,total1,total2;
 Complex com2(7.7);   //调用转换构造函数，将7.7转换成为对象com2 
 total1 = com1+com2;  //两个Complex对象相加 
 total1.print();
 
 com3 = Complex(7.7);
 total2 = com1+com3;
 total2.print();

 return 0;
}

/*
说明：（1）转换构造函数也也是一种构造函数，它遵循构造函数的一般规则。转换构造函数
           只有一个参数，作用是将一个其它类型的数据转换为它所在类的对象。但是，有
           一个参数的不一定是转换构造函数，它也可以是普通的构造函数，仅仅是起对象
           初始化的作用。
      （2）转换构造函数不仅可以将一个系统预定义的标准类型数据转换成类的对象，也有
           可以将另一个类的对象转换为构造函数所在的类对象。
           
           如：可以将一个学生类对象转换为教师类对象，可以在Teacher类中写出下面的
           转换构造函数：
           Teacher(Student& s){ num=s.num;strcpy(name, s.name);sex=s.sex; }
           但应注意，对象s中的num，name，sex必须是公用成员，否则不能被类外引用。        
*/

#include<iostream>
using namespace std;
class Complex{
 public:
   Complex(double r,double i)
   {
    real = r;
    imag = i;
   }
   operator double()          //类型转换函数 
   {
    return real;              //将Complex类的对象转换为一个double类型的数据 
   }
 private:
  double real;
  double imag;
};
int main()
{
 Complex com(2.2,4.4);
 cout<<"Complex类的对象转换为一个double类型的数据:";
 cout<<double(com)<<endl;     //调用类型转化函数，将转换后的double类型的数据显示出来 
 
 return  0;
} 
/*
 类型转换函数注意事项：
   （1）类型转换函数只能定义为一个类的成员函数，而不能定义为友元函数。类型转化函数也可以
        在类体中生命函数原型，而将函数体定义在类的外部。
   （2）类型转换函数既没有参数，也不能在函数名前面指定函数类型。
   （3）类型函数中必须有return语句，即必须送回目标类型的数据作为函数的返回值。
   （4）一个类可以定义多个类型转换函数。C++编译器将根据类型转换函数名自动地选择一个合适的
        类型转换函数予以调用。 
*/

#include<iostream>
using namespace std;
class Complex{
  public:
    Complex(double r,double i)
    {
     real = r;
     imag = i;
    } 
    operator double()  //类型转换函数,将Complex的对象转换为一个double类型的数据 
    {
     return real;
    }
    operator int()
    {
     return int(real); //类型转换函数,将Complex的对象转换为一个int类型的数据 
    }
  private:
    double real;
    double imag;
}; 
int main()
{
 Complex com1(22.2,4.4);
 cout<<"Complex的对象转换为一个double类型的数据:";
 cout<<double(com1)<<endl;//调用类型转换函数 
 
 Complex com2(66.6,4.4); 
 cout<<"Complex的对象转换为一个int类型的数据:";
 cout<<int(com2)<<endl;   //调用类型转换函数
 
 return 0;
} 
/*
运行结果：
          Complex的对象转换为一个double类型的数据:22.2
          Complex的对象转换为一个int类型的数据:66
*/

#include <iostream>
using namespace std;
class Complex
{
public:
   Complex( ){real=0;imag=0;}  //默认构造函数
   Complex(double r){real=r;imag=0;}//转换构造函数
   Complex(double r,double i){real=r;imag=i;}//实现初始化的构造函数
   friend Complex operator + (Complex c1,Complex c2); //重载运算符“+”的友元函数
   void display( );
private:
   double real;
   double imag;
};
Complex operator + (Complex c1,Complex c2)//定义运算符“+”重载函数
{
   return Complex(c1.real+c2.real, c1.imag+c2.imag);
}
void Complex::display( )
{
   cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main( )
{
   Complex c1(3,4),c2(5,-10),c3;
   c3=c1+2.5; //复数与double数据相加，程序中不必显式地调用类型转换函数，它是自动被调用的，即隐式调用 
   c3.display( );//c1+2.5----->c1+Complex(2.5) 
   return 0;
}