二、编写一个规范的类

　　书写一个规范的类，一般包含以下四点。其实在许多教科书上都有提及相关内容，为了保证内容完整性，这里再次强调。

1、防止头文件重复包含，请在头文件中加入ifndef...；

2、成员变量设为私有；

3、请使用常函数(公有接口)来访问私有数据成员；

4、对于有参数构造函数，请使用初始化列表（字段）的方式来初始化私有数据成员；

1、防止头文件重复包含，这个是最基本要求，不多说

#ifndef __COMPLEX__
#define __COMPLEX__

// 类、函数声明
#endif // !COMPLEX_H

2、见complex.h文件 line 24、25

3、常函数见complex.h文件line17、18

4、使用初始化字段来初始化成员变量是一个好习惯，具体见我这篇博客。https://www.cnblogs.com/winslam/articles/9078161.html

complex.h文件

#ifndef __COMPLEX__
#define __COMPLEX__

#include<iostream>
using namespace std;

// 初始化列表，const & 传值， 常函数， return by value or reference

class complex
{
public:
    complex();
    complex::complex(const double real,const double imag)//
        : real_(real), imag_(imag)
    {}
    double real() const;//
    double imag() const;
    complex& operator +=(const complex& cmplx);// 成员函数重载

    ~complex();

private://
    double real_;
    double imag_;

friend ostream& operator << (ostream& out, const complex& cmplx); // const
};

#endif // !COMPLEX_H

注意到27行，是一个友元函数（与上述关键字private无关），当你想要在外部访问对象的私有数据成员的时候，friend函数是一个方法，但是会破坏代码的封装，这时候friend的参数一般都是const类型。

参考我的博客：https://www.cnblogs.com/winslam/articles/9088976.html

complex.cpp文件

#include"complex.h"

complex::complex()
{
    this->real_ = 0.;
    this->imag_ = 0.;
}

double complex::real() const
{
    return this->real_;
}

double complex::imag() const
{
    return this->imag_;
}

// 成员函数重载
complex& complex::operator +=(const complex& cmplx)
{
    this->real_ += cmplx.real_;
    this->imag_ += cmplx.imag_;
    return *this;
}


complex::~complex()
{
}

ostream& operator<<(ostream & out, const complex & cmplx)
{
    out << "(" << cmplx.real_ << "," << cmplx.imag_ << ")";
    return out ;
}

mian.cpp文件

#include<iostream>
using namespace std;

#include"complex.h"

// 非成员函数重载
inline complex
operator +(double real, const complex& cmplx) // 复数左+ 常实数
{
    return complex(real + cmplx.real(), cmplx.imag());
}

inline complex
operator +(const complex& cmplx, double real)// 复数右+ 常实数
{
    return complex(real + cmplx.real(), cmplx.imag());
}

inline complex
operator +(const complex& cmplx1, const complex& cmplx2)// 复数加法
{
    return complex(cmplx1.real() + cmplx2.real(), cmplx2.imag() + cmplx2.imag());
}

inline complex
operator - (const complex& cmplx)//复数乘以(-1)
{
    return complex(-cmplx.real(), -cmplx.imag());
}

inline complex
operator + (const complex& cmplx)//复数乘以(+1)
{
    return cmplx;
}

inline bool
operator == (const complex& cmplx1, const complex& cmplx2)//...
{
    return cmplx1.real() == cmplx2.real() && cmplx1.imag() == cmplx2.imag();
}

int main()
{
    complex cp_1st(1.0, 2.0);
    complex cp_2st(3.0, 4.0);
    cp_2st += cp_1st;
    cout << cp_2st << endl;
    complex cp_3st = 4 + cp_2st;
    cout << cp_3st << endl;
    complex cp_4st = cp_3st + cp_2st;
    cout << cp_4st << endl;
    cout << -cp_4st << endl;
    cout << +cp_4st << cp_2st <<  endl;
    complex cp_5st(1, 2);
    if (cp_1st == cp_5st)
    {
        cout << "==" << endl;
    }
    return 1;
}

 以上是结果。注意到主函数中出现非成员函数的操作符重载，这个问题留到后面说。这一篇博客写得很简洁，也很基础，但是很重要。