侯捷C++（complex类）

按照侯老师的说法，我们去设计一个类时，尽量让人看起来比较专业，注意的点包含但绝不仅限于如下：

注意事项(class without pointer)

1、防卫式的申明，防止头文件的内容被重复包含。
2、成员变量尽量放在private中，要提供相应的接口访问成员变量。
3、成员函数尽量放在public中，提供给外界使用的接口，放在类声明的最前面。
4、成员函数不修改变量的情况下尽量加上const。
5、构造函数可以提供默认实参，尽量使用初始化列表。
6、成员函数中参数传递尽量使用reference。
7、成员函数的返回值也尽量使用reference（建立在非局部变量的情况下）。
8、为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，引入inline修饰符，表示为内联函数。一般选择较为简单的函数（不能包含循环，switch等，且本身不能是直接递归函数）。
9、所有的成员函数一定带有一个指向调用者的指针，全局函数没有this指针。
10、相同的class的各个objects互为friends（友元）。

1.头文件的防卫式说明

complex.h:

#ifndef  __COMPLEX__
#define  __COMPLEX__
class complex
{

}
#endif

2.成员函数和成员变量

成员变量尽量放在private中，要提供相应的接口访问成员变量，成员函数尽量放在public中，提供给外界使用的接口，放在类声明的最前面。

#ifndef  __COMPLEX__
#define __COMPLEX__
class complex
{
    public:
        double real() const {return re;}
        double imag() const {return im;}
    private:
        doubel re,im;
}
#endif

4.成员函数在不修改变量的情况下尽量加上const

例如上面的成员函数：

double real() const {return re;}
double imag() const {return im;}

如果成员函数不会改变成员变量，那就加上const，编译器能帮你确保函数的const属性，阅读代码的人也明确你的意图，与此同时，const对象才可以调用这些函数，const对象不能够调用非const成员函数。

5.构造函数可以提供默认实参，尽量使用初始化列表

class complex
{
    public:
        complex(double r = 0, double i =0)
            : re(r), im(i)  { }
    private:
        doubel re, im;
}

初始化列表这个功能，能用一定用上，这个别人一眼就能看到，要让人看起来专业。

完整一点的代码

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

#include <iostream>
using namespace std;

class Complex
{
public:
    //构造函数，默认实参，成员初始化列表
    //构造函数在对象创建的同时被调用，函数名称与类的名称相同
    //不带指针的类基本不用写析构函数
    //有可能将构造函数放在private中（singleton）单例模式
    Complex (double r = 0, double i = 0) : re(r), im(i) {}

    inline Complex& operator += (const Complex& add);

    inline double real() const {return re;}
    inline double imag() const {return im;}
private:
    double re;
    double im;
    
    //定义为友元能自由取得friend的private成员
    friend Complex& _doapl(Complex*, const Complex&);
};

inline Complex& _doapl(Complex* ths, const Complex& add)
{
    ths->re += add.re;
    ths->im += add.im;
    return *ths;
}
//重载+=
inline Complex& Complex::operator += (const Complex& add)
{
    return _doapl(this, add);
}
//重载<<
inline ostream& operator << (ostream& os, const Complex& x)
{
    return os << '(' << x.real() << ',' << x.imag() << ')' << endl;
}
//typename()创建一个临时对象
inline  Complex operator + (const Complex& x, const Complex& y)
{
    return Complex(x.real() + y.real(), x.imag() + y.imag());
}

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

inline  Complex operator + (const Complex& x, double y)
{
    return Complex(x.real() + y, x.imag());
}
#endif // _COMPLEX_H_