一个Complex类的简单实现

 对于Complex类，最初觉得很容易。写下来之后，对照着大师的评论和实现，发现了差距，也理清了思路。在此贴出，以做参照。

/**/ /************************************************************************
The standard requires that operators = () [] and -> must be members, and 
class-specific operators new, new[], delete, and delete[] must be static members. 
For all other functions:

if the function is operator>> or operator<< for stream I/O,
or if it needs type conversions on its leftmost argument,
or if it can be implemented using the class's public interface alone,
    make it a nonmember (and friend if needed in the first two cases)

    if it needs to behave virtually,
        add a virtual member function to provide the virtual behavior,
        and implement it in terms of that

else
    make it a member
************************************************************************/

#include  < iostream >
using   namespace  std;

template  < typename T >
class  Complex
... {
    template <typename Ty> friend class Complex;

public:
    // In general it's a good idea to make your constructors explicit by default 
    // unless you deliberately decide to allow the implicit conversion
    explicit Complex(T real, T imag = T()) : real_(real), imag_(imag)
    ...{
    }

    // Prefer writing "a op= b;" instead of "a = a op b;" (where op stands for any operator).
    // It's clearer, and it's often more efficient
    template <typename Ty>
    Complex& operator +=(const Complex<Ty>& other)
    ...{
        real_ += other.real_;
        imag_ += other.imag_;
        return *this;
    }

    template <typename Ty>
    Complex& operator -=(const Complex<Ty>& other)
    ...{
        real_ -= other.real_;
        imag_ -= other.imag_;
        return *this;
    }

    // Preincrement should return a reference to non-const梚n this case, Complex&. 
    // This lets client code operate more intuitively and avoids needless inefficiency.
    Complex& operator ++()
    ...{
        ++real_;
        return *this;
    }

    Complex& operator --()
    ...{
        --real_;
        return *this;
    }

    // Postincrement should return a const value in this case, const Complex. 
    // By not allowing changes to the returned object, we prevent questionable code like "a++++", 
    // which doesn't do what a naïve user might think it does.

    // For consistency, always implement postincrement in terms of preincrement. 
    // Otherwise, your users will get surprising (and often unpleasant) results
    const Complex operator ++(int)
    ...{
        Complex temp(*this);
        ++*this;
        return temp;
    }

    const Complex operator --(int)
    ...{
        Complex temp(*this);
        --*this;
        return temp;
    }

    // Add a helper method to avoid friend methods for operator <<
    // and if it is a base class, add virtual to print derived class
    ostream& print(ostream& os) const
    ...{
        return os << "(" << real_ << ", " << imag_ << ")";
    }

private:
    // follow the convention of designating member variable names with a trailing underscore
    T real_, imag_;
} ;

//  Notice the relationship between operators + and +=, - and -=. 
//  The former should be implemented in terms of the latter, 
//  both for simplicity (the code is easier to write) and 
//  for consistency (the two will do the same thing and 
//  are less likely to diverge during maintenance).
template  < class  T1,  class  T2 >
const  Complex < T1 >   operator   + ( const  Complex < T1 >&  lhs,  const  Complex < T2 >&  rhs)
... {
    Complex<T1> ret(lhs);
    ret += rhs;
    return ret;
}

template  < class  T1,  class  T2 >
const  Complex < T1 >   operator   - ( const  Complex < T1 >&  lhs,  const  Complex < T2 >&  rhs)
... {
    Complex<T1> ret(lhs);
    ret -= rhs;
    return ret;
}

//  operator<< should not be a member function.
//  operator<< should have a return type of "ostream&" and 
//  should return a reference to the stream in order to permit chaining. 
//  That way, users can use your operator<< naturally in code like "cout << a << b;".
template  < class  T >
ostream &   operator   << (ostream &  os,  const  Complex < T >&  com)
... {
    return com.print(os);
}

int  main()
... {
    Complex<double> c2(3, 4);
    Complex<double> c3(0.1, 2.5);

    cout << c2 << endl 
         << c3 << endl 
         << c3 + c2 << endl
         << c3 - c2 << endl;

    return getchar();
}