学步园

 #ifndef COMPLEX_H
#define COMPLEX_H
#include <iostream>
#include <iomanip>
class Complex
{
public:
    Complex(double _real,double _imag = 0.0):real(_real),imag(_imag){} //构造函数，初始化列表和默认参数
    Complex(std::istream &is){is >> *this;};                           //输入构造函数，调用自身的>>操作符
    void SetReal(double _real);                                        //更改实部的值
    void SetImag(double _imag);                                        //更改虚部的值
    void SetVal(double _real,double _imag);                            //更改整个复数
    inline double GetReal() const;                                     //获取实部，常成员函数
    inline double GetImag() const;                                     //获取虚部，常成员函数
    Complex& operator+=(const Complex &val);                           //成员操作符+=
    Complex& operator*=(const Complex &val);                           //成员操作符-=
    friend bool operator==(const Complex &lhs,const Complex &rhs);     //友元函数，需访问私有数据
    friend std::istream& operator>>(std::istream &,Complex &);         //友元输入操作符，需私有数据
    friend std::ostream& operator<<(std::ostream &,const Complex &);   //友元输出操作符，需私有数据
private:
    double real;                                                        
    double imag;
};

Complex operator+(const Complex &lhs, const Complex &rhs);              //普通函数，实现两个复数+操作
Complex operator*(const Complex &lhs, const Complex &rhs);              //普通函数，实现两个复数*操作

//========================分割线，此线上面为定义代码，此线下面是实现代码===============================
inline bool operator==(const Complex &lhs,const Complex &rhs)
{
    return (lhs.real == rhs.real) && (lhs.imag == rhs.imag);
}

inline bool operator!=(const Complex &lhs,const Complex &rhs)
{
    return !(lhs==rhs);
}

inline Complex& Complex::operator+=(const Complex &val)
{
    real += val.real;
    imag += val.imag;
    return *this;
}

inline Complex operator+(const Complex &lhs,const Complex &rhs)
{
    Complex ret(lhs);
    ret += rhs;
    return ret;
}

inline Complex& Complex::operator*=(const Complex &val)
{
    double tReal = real;
    double tImag = imag;
    real = tReal*val.real - tImag*val.imag;
    imag = tReal*val.imag + tImag*val.real;
    return *this;
}

inline Complex operator*(const Complex &lhs,const Complex &rhs)
{
    Complex ret(lhs);
    ret *= rhs;
    return ret;
}

inline std::istream& operator>>(std::istream &is,Complex &com)
{
    std::cout << "请输入实数部分：" ;
    is >> com.real;
    if(is)
    {
        std::cout << "请输入虚数部分：" ;
        is >> com.imag;
        if(is)
        {
             return is;
        }
        else
        {
            com = Complex(0.0);
        }
    }
    else
    {
        com = Complex(0.0);
    }
    return is;
}

inline std::ostream& operator<<(std::ostream &os, const Complex &com)
{
    os << "复数为：" << com.real << std::showpos << com.imag << "i" << std::endl;
    return os;
}

inline double Complex::GetReal() const 
{
    return real;
}

inline double Complex::GetImag() const
{
    return imag;
}

void Complex::SetReal(double _real)
{
    real = _real;
}

void Complex::SetImag(double _imag)
{
    imag = _imag;
}

void Complex::SetVal(double _real,double _imag)
{
    real = _real;
    imag = _imag;
}
#endif

 测试代码为：

#include <stdio.h>
#include <tchar.h>
#include <cstdlib>
#include <iostream>
#include <sys/timeb.h>
#include <ctime>
#include <climits>

#include "Complex.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    //测试构造函数
    Complex c1(3,4);
    cout << c1;

    //测试流输入构造函数
    Complex c2(cin);
    cout << c2;

    //测试+
    Complex c3 = c1 + c2;
    cout << c3;

    //测试*
    Complex c4 = c1*c2;
    cout << c4;

    //测试*=
    Complex c5(3,4);
    c5 *= c1;
    cout << c5;

    //测试==
    if(c1==c2)
    {
        cout << "复数c1和c2相等" << endl;
    }
    else
    {
        cout << "复数c1和c2不等" << endl;
    }

    //测试成员函数SetImag
    c1.SetImag(-100.89);
    cout << "更改c1的虚部为-100.89：" << c1; 

    system("pause");
    return 0;
}

转自：http://www.cnblogs.com/zxher/archive/2010/10/25/1860233.html 
虚怀若谷