普通类

​x
1
#ifndef _COMPLEX_
2
#define _COMPLEX_//防卫式声明
3
//一个类尽量做到以下5点：
4
    //1、数据在private
5
    //2、参数尽量用pass by reference,
6
    //3、返回值也尽量用 return by reference，返回的是局部变量则不行
7
    //4、如果不改变参数，则加const
8
    //5、构造函数用初始化列表，而不在函数体内用赋值操作
9

10
#include <cmath>
11
//template <typename T>//模板，成员函数声明和定义的参数列和返回列中，只要是有类名的地方都要加上<T>
12
class complex
13
{
14
private:
15
    /* data */
16
    double re,im;
17
    friend complex& _doapl(complex*,const complex&);
18
public:
19
    complex(/* args */double r = 0,double i = 0)
20
    :re(r),im(i)
21
    {}//函数若是在类内定义完成，便自动成为inline候选人，是不真的变成inline由编译器自己决定
22
    complex& operator += (const complex&);//最好所有参数都传引用，在底层相当于传指针，即地址只有4个字节，比起传值速度会快，因传值会有构造和析构过程
23
                                                //如果又不希望函数改这个参数，则加个const
24
    double real() const {return re;}
25
    double imag() const {return im;}
26
    int func(const complex& param)
27
    {
28
        return param.re + param.im;//这里直接访问了re和im,说明相同class的各个object互为友元
29
    }
30
    ~complex();//一般的，如果类内不含有指针，可以不写析构函数，编译器会有默认的析构函数
31
};
32

33
inline complex&
34
_doapl(complex* ths,const complex& r)//友元自由取得friend的private成员
35
{
36
    ths->re += r.re;
37
    ths->im += r.im;
38
    return *ths;//return by reference语法分析，传递者无需知道接收者是以reference 形式接收
39
                //这儿传递者是传的一个complex类的值，但是因return by reference ，所以返回的是ths地址内的值
40
}
41

42
complex::~complex()//一般的，如果类内不含有指针，可以不写析构函数，编译器会有默认的析构函数
43
{
44

45
}
46
//操作符重载
47
//c2 += c1; +=操作符的左边有没有定义+=函数，它的右边会被传到+=操作符的函数参数里去
48
complex& complex::operator += (const complex& rhs)
49
{
50
    return _doapl(this,rhs);
51
}
52

53
inline double//建议编译器把它作为内联函数，实际作不作只有编译器知道
54
imag (const complex& x)
55
{
56
  return x.imag ();
57
}
58

59
inline double
60
real (const complex& x)
61
{
62
  return x.real ();
63
}
64

65
//任何一种操作符都可以有两种想法，可以是写成成员函数，也可以写成全局函数
66
//为了对付client的三种可能用法，这儿对应开发三个函数
67
//操作符载，非成员函数，无this
68
//下面这三个函数绝不可return by reference,因为，它们返回的必定是个local object
69
//返回语句中是用的，typename+小括号，编译器会建一个临时对象，到下一行生命周期结束
70

71
inline complex
72
operator + (const complex& x,const complex& y)
73
{
74
    return complex (real(x) + real(y),
75
                        imag(x) + imag(y));
76
}
77

78
inline complex
79
operator + (const complex& x,double y)
80
{
81
    return complex (real(x) + y,imag(x));
82
}
83

84
inline complex
85
operator + (double x,const complex& y)
86
{
87
    return complex (x + real(y),imag(y));
88
}
89
//再加正，负号操作符重载
90

91
inline complex//这儿因为返回的不是局部变量，所以也可以用inline complex<T>&
92
operator + (const complex& x)
93
{
94
    return x;
95
}
96
inline complex
97
operator - (const complex& x)
98
{
99
    return complex (-real(x),-imag(x));
100
}
101
//比较复数等不等
102

103
inline bool
104
operator == (const complex& x,const complex& y)
105
{
106
    return real(x)==real(y) && imag(x)==imag(y);
107
}
108
//共轭复数：实部相等，虚部取反
109

110
inline complex
111
conj (const complex& x)
112
{
113
    return complex (real(x),-imag(x));
114
}
115
//输出操作符重载，这个不可以是成员函数，则使用时只能写成c1<<cout，和习惯用法相反
116
#include <iostream>
117
using namespace std;
118
ostream&//返回ostream&的目的，是为了用户可以连续输出，比如：cout<<c1<<c2<<endl;
119
        //如果不考虑连续输出，这个函数就可以不要返回值。
120
operator <<(ostream& os,const complex& x)//这儿前一个参数不能加const,因为return中相当于改了os的状态
121
{
122
    return os <<'('<<real(x)<<','<<imag(x)<<')';
123
}
124
#endif
125

126