C++类设计1（Class without pointer members）

class complex{
    public:
        complex (double r = 0, double i = 0):re(r), im(i){} //inline
        complex& operator += {const complex&};          
        double real() const{return re;}   //inline
        double imag() const{return im;}  //inline
    private:
        double re,im;
        friend complex& _doap1 (complex*, const complex); 
}; 
inline double imag(const complex& x){          //inline
        return x.imag();        
}                

class complex{
    public:
        complex (double r = 0, double i = 0):re(r), im(i) {} //可以带参数，参数可以有默认值，即未指明时使用默认值
                                                             //初始化列表 : re(r),im(i) 能使用初始化列表时尽量使用
        complex& operator += {const complex&};
        double real() const{return re;}
        double imag() const{return im;}
    private:
        double re,im;
        friend complex& _doap1 (complex*, const complex); 
}; 

{
    complex c1(2,1);            //三种方式均调用构造函数
    complex c2;
    complex *p = new complex(4);
    ... 
}

class A{
public:
    static A& getInstance();  //静态类型变量
    setup(){}
private:
    A();       //构造函数在private区域
    A(const A& ths);
    ...     
}; 
A& A::getInstance(){
    static A a;
    return a; 
}

A::getInstance().setup();  //使用时利用类的getInstace()函数

double real() const {return re;}
void real(double r) {re = r;}    //正确重载
complex(double r= 0, double i = 0): re(r),im(i) {};
complex() : re(r), im(i){};  // 错误，编译器无法判断， 如： complex c1; 不知道调用哪个。

double real() const{return re;}
double imag() const{return im;}
//不改变数据内容，则一定要加const，否则可能引起错误，如：
//外界调用该函数时 使用：const complex c1(1,2);  
//声明常对象，常对象不可调用非常成员函数，出现错误

class complex{
    public:
        complex (double r = 0, double i = 0):re(r), im(i){}   //pass by value 
        complex& operator += {const complex&};                //pass by reference
        double real() const{return re;}
        double imag() const{return im;}
    private:
        double re,im;
        friend complex& _doap1 (complex*, const complex&);    //pass by reference
}; 

complex& operator += {const complex&};
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);
}

inline complex&
__doapl(complex* ths, const complex& r)
{
    ths->re += r.re;
    ths->im += r.im;
    return *ths;                   
}

friend complex& __doapl (complex*, const complex&);

inline complex&
_doap1 (complex* ths, const complex& r){
    ths->re += r.re;                       //自由取得friend的private变量，但破坏封装
    ths->im +=r.im;
    return *ths;
}

class complex{
public:
    complex (double r = 0, double i = 0):re(r),im(i){
    }
    int func(const complex& param){
        return param.re + param.im；
    }                                     //直接拿param私有变量，可以用相同类的各个对象之间互为友元解释
private:
    double re, im;
};

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)              //operator += 在程序员使用时可能采用c1 += c2 += c3形式
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　// 故需要返回complex&类型，不能是void, 类似还有重载cout返回类型
{
    return __doapl (this, r)
}

inline complex
operator + (const complex& x, const complex& y)
{
    return complex (real (x) + real (y),
            imag (x) + imag (y));                       //返回的是函数内临时变量（local object），函数结束后消亡，故不可使用return by reference 
}
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));
}

#include
ostream& 
operator << (ostream& os, const complex&){     //两个参数为 << 左边和右边，如 cout << c1; cout类型为ostream,
    return os << ‘(‘ << real(x) << ‘,‘
              << imag(x) << ‘)‘;
}