侯捷老师C++大系之C++面向对象开发：（一）不带指针的类：Complex复数类的实现过程

一、笔记
1.C++编程简介

2.头文件与类的声明

防卫式声明
#ifndef __COMPLEX__
#define __COMPLEX__

……

#endif
头文件的布局
模板简介
template<typename T>
3.构造函数

inline函数：函数若在class body内定义完成，便自动成为inline候选人

访问级别：
public private
被外部访问的函数设为public

构造函数
complex (doble r=0,double i=0)
:re(r),im(i)
{ }
先初始化，后赋值
这种写法效率高

构造函数可以有很多个——重载

单例模式，构造函数放在private里，不允许外部创

4.参数传递与返回值

在函数后头加const
double real () const{return re;}

参数传递： pass by value vs. pass by reference(to const)
参数尽量传引用，如果不希望对方改加const
内化成习惯
返回值传递：return by value vs. return by reference(to const)
返回值也尽量传引用

friend（友元）
自由取得friend的private成员
相同class的各个objects互为friends（友元）

class body外的各种定义

什么情况可以传和返回引用，什么情况不可以：
两个参数相加，得到一个新的结果时不能传引用

5.操作符重载与临时对象

操作符重载之一，成员函数
操作符重载之二，非成员函数
临时对象

重载<<

二、代码
1.complex.h

 #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 = , double i = ): re (r), im (i) { }
   complex& operator += (const complex&);
   complex& operator -= (const complex&);
   complex& operator *= (const complex&);
   complex& operator /= (const complex&);
   double real () const { return re; }
   double imag () const { return im; }
 private:
   double re, im;

   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);
 }

 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) == ;
 }

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

 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) != ;
 }

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

 #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__

2.complex_test.cpp

 #include <iostream>
 #include "complex.h"

 using namespace std;

 ostream&
 operator << (ostream& os, const complex& x)
 {
   return os << '(' << real (x) << ',' << imag (x) << ')';
 }

 int main()
 {
   complex c1(, );
   complex c2(, );

   cout << c1 << endl;
   cout << c2 << endl;

   cout << c1+c2 << endl;
   cout << c1-c2 << endl;
   cout << c1*c2 << endl;
   cout << c1 /  << endl;

   cout << conj(c1) << endl;
   cout << norm(c1) << endl;
   cout << polar(,) << endl;

   cout << (c1 += c2) << endl;

   cout << (c1 == c2) << endl;
   cout << (c1 != c2) << endl;
   cout << +c2 << endl;
   cout << -c2 << endl;

   cout << (c2 - ) << endl;
   cout << ( + c2) << endl;

   return ;
 }