复数类 class complex

最新推荐文章于 2024-06-25 08:00:00 发布

赤城封雪

最新推荐文章于 2024-06-25 08:00:00 发布

阅读量489

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/chichengfengxue/article/details/117340117

版权

精华版

#ifndef __MYCOMPLEX__  // 防卫式声明
#define __MYCOMPLEX__

class complex; 
complex&
  __doapl (complex* ths, const complex& r);

class complex
{
public://公有成员
  complex (double r = 0, double i = 0)//构造函数，可设置默认值
  : re (r), im (i)//初始化
  { }
  complex& operator += (const complex&);//运算符重载
  complex& operator -= (const complex&);//&operator返回地址
  complex& operator *= (const complex&);
  complex& operator /= (const complex&);
  double real () const { return re; }//数据接口(封装)
  double imag () const { return im; }//常成员函数 "()const{}"
private://私有成员
  double re, im;//数据应尽量private

  friend complex& __doapl (complex *, const complex&);//友元
};

//运算符+=重载
inline complex& //内联函数
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
 
inline complex&
complex::operator += (const complex& r)
{
  return __doapl (this, r);//this指针指向自身对象
}

inline double
imag (const complex& x)//访问私有数据成员
{
  return x.imag ();
}

inline complex operator + (const complex& x, const complex& y)//重载运算符 +
{
  return complex (real (x) + real (y), imag (x) + imag (y));//返回对象
}

inline complex
operator + (const complex& x)//重载单目运算符 +
{
  return x;
}

inline bool
operator == (const complex& x, const complex& y)//重载运算符 ==
{
  return real (x) == real (y) && imag (x) == imag (y);
}

完整版

#ifndef __MYCOMPLEX__  // 防卫式声明
#define __MYCOMPLEX__

class complex; 
complex&
  __doapl (complex* ths, const complex& r);
complex&
  __doami (complex* ths, const complex& r);
complex&
  __doaml (complex* ths, const complex& r);


class complex
{
public://公有成员
  complex (double r = 0, double i = 0)//构造函数，可设置默认值
  : re (r), im (i)//初始化
  { }
  complex& operator += (const complex&);//运算符重载
  complex& operator -= (const complex&);//&operator返回地址
  complex& operator *= (const complex&);
  complex& operator /= (const complex&);
  double real () const { return re; }//数据接口(封装)
  double imag () const { return im; }//常成员函数 "()const{}"
private://私有成员
  double re, im;//数据应尽量private

  friend complex& __doapl (complex *, const complex&);//友元
  friend complex& __doami (complex *, const complex&);
  friend complex& __doaml (complex *, const complex&);
};


inline complex& //内联函数
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
 
inline complex&
complex::operator += (const complex& r)
{
  return __doapl (this, r);//this指针指向自身对象
}

inline complex&
__doami (complex* ths, const complex& r)
{
  ths->re -= r.re;
  ths->im -= r.im;
  return *ths;
}
 
inline complex&
complex::operator -= (const complex& r)
{
  return __doami (this, r);
}
 
inline complex&
__doaml (complex* ths, const complex& r)
{
  double f = ths->re * r.re - ths->im * r.im;
  ths->im = ths->re * r.im + ths->im * r.re;
  ths->re = f;
  return *ths;
}

inline complex&
complex::operator *= (const complex& r)
{
  return __doaml (this, r);
}
 
 
inline double
imag (const complex& x)
{
  return x.imag ();
}

inline double
real (const complex& x)
{
  return x.real ();
}

inline complex operator + (const complex& x, const complex& y)//重载运算符 +
{
  return complex (real (x) + real (y), imag (x) + imag (y));//返回对象
}

inline complex
operator + (const complex& x, double y)//复数＋实数
{
  return complex (real (x) + y, imag (x));
}

inline complex
operator + (double x, const complex& y)
{
  return complex (x + real (y), imag (y));
}

inline complex
operator - (const complex& x, const complex& y)
{
  return complex (real (x) - real (y), imag (x) - imag (y));
}

inline complex
operator - (const complex& x, double y)
{
  return complex (real (x) - y, imag (x));
}

inline complex
operator - (double x, const complex& y)
{
  return complex (x - real (y), - imag (y));
}

inline complex
operator * (const complex& x, const complex& y)
{
  return complex (real (x) * real (y) - imag (x) * imag (y),
			   real (x) * imag (y) + imag (x) * real (y));
}

inline complex
operator * (const complex& x, double y)
{
  return complex (real (x) * y, imag (x) * y);
}

inline complex
operator * (double x, const complex& y)
{
  return complex (x * real (y), x * imag (y));
}

complex
operator / (const complex& x, double y)
{
  return complex (real (x) / y, imag (x) / y);
}

inline complex
operator + (const complex& x)
{
  return x;
}

inline complex
operator - (const complex& x)
{
  return complex (-real (x), -imag (x));
}


inline bool
operator == (const complex& x, const complex& y)
{
  return real (x) == real (y) && imag (x) == imag (y);
}

inline bool
operator == (const complex& x, double y)
{
  return real (x) == y && imag (x) == 0;
}

inline bool
operator == (double x, const complex& y)
{
  return x == real (y) && imag (y) == 0;
}

inline bool
operator != (const complex& x, const complex& y)
{
  return real (x) != real (y) || imag (x) != imag (y);
}

inline bool
operator != (const complex& x, double y)
{
  return real (x) != y || imag (x) != 0;
}

inline bool
operator != (double x, const complex& y)
{
  return x != real (y) || imag (y) != 0;
}

#include <cmath>

inline complex
polar (double r, double t)
{
  return complex (r * cos (t), r * sin (t));
}

inline complex
conj (const complex& x) //共轭复数
{
  return complex (real (x), -imag (x));
}

inline double
norm (const complex& x)
{
  return real (x) * real (x) + imag (x) * imag (x);
}

#endif   //__MYCOMPLEX__