Complex类的实现过程

Complex.h

#ifndef _COMPLEX_
#define _COMPLEX_ //防卫式声明
#include <iostream>
using namespace std;

class complex
{
public:
    complex(double r = 0, double i = 0):re(r), im(i) { } //构造函数初始化，形参无论pass by value还是pass by reference都占用4个字节
    complex& operator += (const complex&);
    double real() const {return re;} //函数不需要改动数据，加关键字const
    double imag() const {return im;}

private:
    double re, im;

    friend complex& _doap1(complex *, const complex&);
};

inline complex& _doap1(complex* ths, const complex& r)
{
    ths->re +=r.re;
    ths->im += r.im; //友元可以直接访问类private中的数据
    return *ths;
}

inline complex& complex::operator += (const complex& r) //这里有一个隐藏参数，+=左边的东西
{
    return _doap1(this, r);
}

inline complex operator + (const complex& x, const complex& y)
{
    return complex(x.real() + y.real(), x.imag() + y.imag()); //类名()：创建一个新的对象，临时对象
} 

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

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

ostream& operator << (ostream& os, const complex& x)
{
    os << "(" << x.real() << "," << x.imag() << ")" << endl;
    return os;
}
#endif

Complex_test.cpp

#include "Complex.h"

int main()
{
    complex c1(2, 3);
    complex c2(2);
    complex c3;
    c2 += c1;
    cout << c2 << endl;
    c2 += 5;
    cout << c2 << endl;
    c3 = c1 + 5;
    cout << c1 << c3 << endl;

    return 0;
}

1、C++ Primer中说，iostream标准库兼容的输入，输出运算符必须是普通的非成员函数，而不能成为类的成员函数。这里可以理解为<<是双目运算符，如果是类的成员函数，那么<<左侧应该是类本身，cout << c1的左侧是cout，不能是类的成员函数。 operator +=,operator =可以是类的成员函数。
2、类型转换函数的一般形式：

operator 类型名()
{
    实现转换的语句
}

class Complex
{
public:
    ...
    operator double() const {return re;}

}；
int main()
{
    Complex c(5, 5);
    double d;
    d = 5.5 + c;//对c调用类型转换函数
}

　　如果把下面的代码直接加入到Complex.h中会出现错误，这是因为此时编译器有两种可以解决的办法：① 将c转换为double类型，再和5.5想加；② 将5.5转换为Complex类型和c相加，再将得到的结果转为double类型。编译器不知道应该选择哪个方案解决问题，就会报错。
　　解决的方法是在构造函数前加上explicit关键字，这个关键字的作用使得编译器不能自动将5.5转换为Complex类型，这个时候5.5就是double类型，这样就只有方案一可以解决问题，编译器就不会再纠结了（但是c2 += 5；受到影响，这行语句会出现错误，需要改为c2 += 5.0）。第二种解决办法就是将operator+函数删掉。可以用下面的例子理解：

class Fraction
{
public:
    Fraction(int num, int den = 1)
    :m_numerator(num), m_denominator(den) { }
    operator double() const 
    {
        return (double)(m_numerator / m_denominator);
    }
private:
    int m_numerator; //分母
    int m_denominator; //分子
};

int main()
{
    Fraction f(3, 5);
    double d = f + 4; //调用operator double()将f转换为0.6
    return 0;
}

class Fraction
{
public:
    Fraction(int num, int den = 1)
    :m_numerator(num), m_denominator(den) { }
    Fraction operator+ (const Fraction& f)
    {
        return Fraction(...);
    }
private:
    int m_numerator; //分母
    int m_denominator; //分子
};

int main()
{
    Fraction f(3, 5);
    Fraction d2 = f + 4; //调用non-explicit ctor将4转换为Fraction
                         //然后调用operator+
    return 0;
}

class Fraction
{
public:
    Fraction(int num, int den = 1)
    :m_numerator(num), m_denominator(den) { }
    Fraction operator+ (const Fraction& f)
    {
        return Fraction(...);
    }
private:
    int m_numerator; //分母
    int m_denominator; //分子
};

int main()
{
    Fraction f(3, 5);
    Fraction d2 = f + 4; //调用non-explicit ctor将4转换为Fraction
                         //然后调用operator+
    return 0;
}

class Fraction
{
public:
    Fraction(int num, int den = 1)
    :m_numerator(num), m_denominator(den) { }
    operator double() const 
    {
        return (double)(m_numerator / m_denominator);
    }
    Fraction operator+ (const Fraction& f)
    {
        return Fraction(...);
    }
private:
    int m_numerator; //分母
    int m_denominator; //分子
};

int main()
{
    Fraction f(3, 5);
    Fraction d2 = f + 4; //[Error]ambiguous
    return 0;
}

　　这时代码产生二意，编译器不知道怎样选择，解决办法是在构造函数前加上explicit关键字。告诉编译器不要把4自动变成一分之四，就只是构造函数而已。这样4无法转为Fraction，operator+就失效了。

explicit Fraction(int num, int den = 1)
:m_numerator(num),m_denominator(den) { }