C++编写的复数类

头文件为：

#ifndef COMPLEX_H
#define  COMPLEX_H
#include  < iostream >
#include  < iomanip >
class  Complex
{
public :
    Complex( double  _real, double  _imag  =   0.0 ):real(_real),imag(_imag){}  // 构造函数，初始化列表和默认参数
    Complex(std::istream  & is ){ is   >>   * this ;};                            // 输入构造函数，调用自身的>>操作符
     void  SetReal( double  _real);                                         // 更改实部的值
     void  SetImag( double  _imag);                                         // 更改虚部的值
     void  SetVal( double  _real, double  _imag);                             // 更改整个复数
    inline  double  GetReal()  const ;                                      // 获取实部，常成员函数
    inline  double  GetImag()  const ;                                      // 获取虚部，常成员函数
    Complex &   operator += ( const  Complex  & val);                            // 成员操作符+=
    Complex &   operator *= ( const  Complex  & val);                            // 成员操作符-=
    friend  bool   operator == ( const  Complex  & lhs, const  Complex  & rhs);      // 友元函数，需访问私有数据
    friend std::istream &   operator >> (std::istream  & ,Complex  & );          // 友元输入操作符，需私有数据
    friend std::ostream &   operator << (std::ostream  & , const  Complex  & );    // 友元输出操作符，需私有数据
private :
     double  real;                                                        
     double  imag;
};

Complex  operator + ( const  Complex  & lhs,  const  Complex  & rhs);               // 普通函数，实现两个复数+操作
Complex  operator * ( const  Complex  & lhs,  const  Complex  & rhs);               // 普通函数，实现两个复数*操作



// ========================分割线，此线上面为定义代码，此线下面是实现代码===============================
inline  bool   operator == ( const  Complex  & lhs, const  Complex  & rhs)
{
     return  (lhs.real  ==  rhs.real)  &&  (lhs.imag  ==  rhs.imag);
}

inline  bool   operator != ( const  Complex  & lhs, const  Complex  & rhs)
{
     return   ! (lhs == rhs);
}

inline Complex &  Complex:: operator += ( const  Complex  & val)
{
    real  +=  val.real;
    imag  +=  val.imag;
     return   * this ;
}

inline Complex  operator + ( const  Complex  & lhs, const  Complex  & rhs)
{
    Complex ret(lhs);
    ret  +=  rhs;
     return  ret;
}

inline Complex &  Complex:: operator *= ( const  Complex  & val)
{
     double  tReal  =  real;
     double  tImag  =  imag;
    real  =  tReal * val.real  -  tImag * val.imag;
    imag  =  tReal * val.imag  +  tImag * val.real;
     return   * this ;
}

inline Complex  operator * ( const  Complex  & lhs, const  Complex  & rhs)
{
    Complex ret(lhs);
    ret  *=  rhs;
     return  ret;
}

inline std::istream &   operator >> (std::istream  & is ,Complex  & com)
{
    std::cout  <<   " 请输入实数部分： "  ;
     is   >>  com.real;
     if ( is )
    {
        std::cout  <<   " 请输入虚数部分： "  ;
         is   >>  com.imag;
         if ( is )
        {
              return   is ;
        }
         else
        {
            com  =  Complex( 0.0 );
        }
    }
     else
    {
        com  =  Complex( 0.0 );
    }
     return   is ;
}

inline std::ostream &   operator << (std::ostream  & os,  const  Complex  & com)
{
    os  <<   " 复数为： "   <<  com.real  <<  std::showpos  <<  com.imag  <<   " i "   <<  std::endl;
     return  os;
}

inline  double  Complex::GetReal()  const  
{
     return  real;
}

inline  double  Complex::GetImag()  const
{
     return  imag;
}

void  Complex::SetReal( double  _real)
{
    real  =  _real;
}

void  Complex::SetImag( double  _imag)
{
    imag  =  _imag;
}

void  Complex::SetVal( double  _real, double  _imag)
{
    real  =  _real;
    imag  =  _imag;
}
#endif

 

 

 测试代码为：

 

#include  < stdio.h >
#include  < tchar.h >
#include  < cstdlib >
#include  < iostream >
#include  < sys / timeb.h >
#include  < ctime >
#include  < climits >

#include  " Complex.h "
using   namespace  std;

int  _tmain( int  argc, _TCHAR *  argv[])
{
     // 测试构造函数
    Complex c1( 3 , 4 );
    cout  <<  c1;

     // 测试流输入构造函数
    Complex c2(cin);
    cout  <<  c2;

     // 测试+
    Complex c3  =  c1  +  c2;
    cout  <<  c3;

     // 测试*
    Complex c4  =  c1 * c2;
    cout  <<  c4;

     // 测试*=
    Complex c5( 3 , 4 );
    c5  *=  c1;
    cout  <<  c5;

     // 测试==
     if (c1 == c2)
    {
        cout  <<   " 复数c1和c2相等 "   <<  endl;
    }
     else
    {
        cout  <<   " 复数c1和c2不等 "   <<  endl;
    }

     // 测试成员函数SetImag
    c1.SetImag( - 100.89 );
    cout  <<   " 更改c1的虚部为-100.89： "   <<  c1; 

    system( " pause " );
     return   0 ;
}

 

 

转载于:https://www.cnblogs.com/zxher/archive/2010/10/25/1860233.html