题目
定义一个复数类 Complex，虚部和实部为私有数据类型
相关阅读
相关阅读
完整代码
#include<bits/stdc++.h>
using namespace std;

class Complex{
private:
    double re, im;
public:
    Complex(){
        re = 0;
        im = 0;
    };
    double real() const {return  re;};
    double imag() const {return im;};
    void show(){
        if (imag() >= 0)
            cout << real() << " + " << imag() << "i" << endl;
        else
            cout << real() << " - " << -imag() << "i" << endl;
    }

    Complex& operator+=(Complex complex){
        this->re += complex.re;
        this->im += complex.im;
        return *this;
    };
    Complex& operator+=(double i){
        this->re += i;
        return *this;
    };
    Complex& operator-(){
        this->re = -re;
        this->im = -im;
        return *this;
    }
    Complex& operator+(){
        return *this;
    }
    friend Complex operator+(Complex complex1, Complex complex2);
    friend Complex operator+(double real, Complex complex2);
    friend Complex operator+(Complex complex1, double real);
    friend Complex operator-(Complex complex1, Complex complex2);
    friend Complex operator-(double real, Complex complex2);
    friend Complex operator-(Complex complex1, double real);
    friend ostream& operator<<(ostream& out, Complex complex1);
    friend istream& operator>>(istream& in, Complex &complex1);
    friend Complex operator*(Complex complex1, Complex complex2);
    friend Complex operator*(double real, Complex complex2);
    friend Complex operator*(Complex complex1, double real);
    friend Complex operator/(Complex complex1, Complex complex2);
    friend Complex operator/(double real, Complex complex2);
    friend Complex operator/(Complex complex1, double real);
};
Complex operator+(Complex complex1, Complex complex2){
    Complex temp;
    temp.re = complex1.re + complex2.re;
    temp.im = complex1.im + complex2.im;
    return temp;
}
Complex operator+(double real, Complex complex2){
    Complex temp;
    temp.re = real + complex2.re;
    temp.im = complex2.im;
    return temp;
}
Complex operator+(Complex complex1, double real){
    Complex temp;
    temp.re = real + complex1.re;
    temp.im = complex1.im;
    return temp;
}
Complex operator-(Complex complex1, Complex complex2){
    Complex temp;
    temp.re = complex1.re - complex2.re;
    temp.im = complex1.im - complex2.im;
    return temp;
}
Complex operator-(double real, Complex complex2){
    Complex temp;
    temp.re = real - complex2.re;
    temp.im = -complex2.im;
    return temp;
}
Complex operator-(Complex complex1, double real){
    Complex temp;
    temp.re = complex1.re - real;
    temp.im = complex1.im;
    return temp;
}
Complex operator*(Complex complex1, Complex complex2){
    Complex temp;
    temp.re = complex1.re*complex2.re - complex1.im*complex2.im;
    temp.im = complex1.im*complex2.re + complex1.re*complex2.im;
    return temp;
}
Complex operator*(double real, Complex complex2){
    Complex temp;
    temp.re = real*complex2.re;
    temp.im = real*complex2.im;
    return temp;
}
Complex operator*(Complex complex1, double real){
    Complex temp;
    temp.re = real*complex1.re;
    temp.im = real*complex1.im;
    return temp;
}
Complex operator/(Complex complex1, Complex complex2){
    Complex temp;
    temp.re = (complex1.re*complex2.re + complex1.im*complex2.im) /
            (complex2.re*complex2.re + complex2.im*complex2.im);
    temp.im = (complex1.im*complex2.re - complex1.re*complex2.im) /
            (complex2.re*complex2.re + complex2.im*complex2.im);
    return temp;
}
Complex operator/(double real, Complex complex2){
    Complex temp;
    temp.re = (real*complex2.re) /
              (complex2.re*complex2.re + complex2.im*complex2.im);
    temp.im = (-real*complex2.im) /
              (complex2.re*complex2.re + complex2.im*complex2.im);
    return temp;
}
Complex operator/(Complex complex1, double real){
    Complex temp;
    temp.re = (complex1.re*real) /
              (real*real);
    temp.im = (complex1.im*real) /
              (real*real);
    return temp;
}
ostream& operator<<(ostream& out, Complex complex1){
    if (complex1.imag() >= 0)
        out << complex1.real() << " + " << complex1.imag() << "i" << endl;
    else
        out << complex1.real() << " - " << -complex1.imag() << "i" << endl;
}
istream& operator>>(istream& in, Complex& complex1){
    in >> complex1.re >> complex1.im;
}
int main(){
    Complex c1, c2;
    double i = 2.0;
    cin >> c1 >> c2;
    cout << c1+c2;
    cout << i+c2;
    cout << c1+i;
    cout << c1-c2;
    cout << i-c2;
    cout << c2-i;
    c1 += c2;
    cout << -c2;
    cout << +c2;
    cout << c1*c2;
    cout << i*c2;
    cout << c1*i;
    cout << c1/c2;
    cout << i/c2;
    cout << c1/i;
}

定义复数类Complex，包括两个double型的数据成员real和image，要求对+、-、、/、+=、-+、=、/=、几个运算符进行重载以实现复数的运算，并进行验证。



#define _CRT_SECURE_NO_WARNINGS   
#include <iostream>  
using namespace std;

class Complex
{
public:
    //默认的构造函数（含缺省值，并初始化参数）  
    Complex(const double real = 0.0, const double image = 0.0)
        :_real(real)  //初始化
        , _image(image)
    {}

    //拷贝构造函数  
    Complex(const Complex& c)
    {
        _real = c._real;
        _image = c._image;
    }
    //析构函数  
    ~Complex()
    {}
    //赋值运算符的重载  
    Complex& operator=(const Complex& c)
    {
        this->_real = c._real;
        //_real = c._real;//隐含的this指针
        this->_image = c._image;
        //_image = c._image;
        return *this;
    }
    //加法运算符的重载  
    Complex operator+(const Complex& c)
    {
        Complex tmp;
        tmp._real = _real + c._real;
        tmp._image = _image + c._image;
        return tmp;
    }
    //减法
    Complex operator-(const Complex& c)
    {
        Complex tmp;
        tmp._real = _real - c._real;
        tmp._image = _image - c._image;
        return tmp;
    }
    //乘法
    Complex operator*(const Complex& c)
    {
        Complex tmp;
        tmp._real = _real * c._real - _image*c._image;
        tmp._image = _real * c._image + _image*c._real;
        return tmp;
    }
    //除法
    Complex operator/(const Complex& c)
    {
        Complex tmp;
        tmp._real = (_real / c._real + _image*c._image) / (c._real*c._real + c._image*c._image);
        tmp._image = (_image*c._real - _real*c._image) / (c._real*c._real + c._image*c._image);
        return tmp;
    }
    Complex operator+=(const Complex& c)
    {
        _real += c._real;
        _image += c._image;
        return *this;
    }
    Complex operator-=(const Complex& c)
    {
        _real -= c._real;
        _image -= c._image;
        return *this;//返回当前对象
    }
    Complex operator*=(const Complex& c)
    {
        double real0 = _real;
        double image0 = _image;
        _real = (real0 * c._real - image0*c._image);
        _image = (real0 * c._image + image0*c._real);
        return *this;
    }
    Complex operator/=(const Complex& c)
    {
        double real0 = _real;
        double image0 = _image;
        _real /= (real0 / c._real + image0*c._image) / (c._real*c._real + c._image*c._image);
        _image /= (image0*c._real - real0*c._image) / (c._real*c._real + c._image*c._image);
        return *this;
    }

    void Display()
    {
        cout << _real << " " << _image << endl;
    }

private:
    double _real;
    double _image;
};
//测试函数  
void Funtest1()
{
    Complex c1(2.0, 3.0);
    c1.Display();
    Complex c2(c1);
    c2.Display();
    Complex c3;
    c3 = c1+c2;  
    c3.Display();

}
void Funtest2()
{
    Complex c1(2.0, 3.0);
    c1.Display();
    Complex c2(c1);
    c2.Display();
    c1 *= c2;
    c1.Display();
}

int main()
{
    cout << "Funtest1:" << endl;
    Funtest1();
    cout << "Funtest2:" << endl;
    Funtest2();
    getchar();
    return 0;
}

运行结果 

---》：原则上复数是不能比较大小的，此处主要是练习运算符重载才写的复数比较大小：

#include<iostream>
using namespace std;
class Complex 
{ 
public:  
	Complex(double real = 0.0,double image = 0.0) //构造函数
		:_real(real)
		,_image(image)
	{}
	Complex(const Complex& c)  //拷贝构造函数
		:_real(c._real)
		,_image(c._image)
	{}
	~Complex()  //析构函数
	{}
	void Display()  //显示函数
	{
		cout<<_real<<"+"<<_image<<"i"<<endl;
	}
	Complex operator+(Complex c)  //重载+函数
	{
		_real = _real + c._real;
		_image = _image + c._image;
		return *this;
	}
	bool operator>(const Complex& c)const  //重载>函数
	{
		if(_real>c._real)
			return true;
		else if(_real==c._real)
		{
			if(_image>c._image)
			{
				return true;
			}
			else
				return false;
		}
		else
			return false;
	}
	bool operator<(const Complex& c)const //重载<函数
	{
		if(_real<c._real)
			return true;
		else if(_real==c._real)
		{
			if(_image<c._image)
			{
				return true;
			}
			else
				return false;	
		}
		else
			return false;	
	}
	bool operator ==(const Complex& c)const  //重载==函数
	{
		if((_real == c._real)&&(_image == c._image))
			return true;
		else
			return false;
	}
	bool operator!=(const Complex& c)  //重载！=函数
	{
		return !(*this == c);
	}
	Complex& operator=(const Complex& c)
	{
		_real = c._real;
		_image = c._image;
		return *this;
	}
	
	Complex operator++()  //前置++
	{
		_real++;
		return *this;
	}
	Complex operator++(int)  //后置++
	{
		Complex temp = *this;
		_real++;
		return temp;
	}
	Complex operator--()  //前置--
	{
		_real--;
		return *this;
	}
	Complex operator--(int)  //后置--
	{
		Complex temp = *this;
		_real--;
		return temp;
	}
	Complex operator+=(double x)  //重载+=函数
	{
		_real += x;
		return *this;
	}
protected: 
	double _real; 
	double _image; 
}; 
void Test1()  // +(加)、++(后置)、++（前置）
{
	Complex c1(1,2);
	Complex c2(2,3);
	Complex c3(3,5);
	Complex c4,c5,c6;
	c4=(c1+c2);
	c4.Display();
	c5=c2++;
	c5.Display();
	c6=++c3;
	c6.Display();
}
void Test2()// >（大于）、<（小于）、+=(加等)、==（等于）
{
	Complex c1(2,2);
	Complex c2(4,3);
	Complex c3(3,5);
	bool c = true;
	c=c1<c2;
	cout<<c<<endl;
	c=c1>c3;
	cout<<c<<endl;
	Complex c4(2,2);
	Complex c5;
	c5=c4+=3;
	c5.Display();
	Complex c6(2,2);
	c=c1==c6;
	cout<<c<<endl;	
}
int main()
{
	Test1();
	Test2();
	return 0;
}

(1)复数类Complex的属性有：

RealPart：int型，代表复数的实数部分，

ImaginPart;int型，代表复数的虚数部分

(2)复数类Complex的方法有，

Complex()：构造函数，将复数的实部和虚部都置0。

Complex(int r.int i)：构造函数，形参r为实部的初值，为虚部的初值。

Complex complexAdd(Complex a)：将当前复数对象与形参复数对象相加，所得的结

果仍是一个复数值，返回给此方法的调用者。

String ToString()：把当前复数对象的实部、虚部组合成a+bi的字符串形式，其中a和b分别为实部和虚部的数据。

Calca类
public class Calca {
	public static void main(String[] args) {
		Complex a=new Complex(1,2);
		Complex b=new Complex(3,4);
		System.out.println("a="+a.ToString());
		System.out.println("b="+b.ToString());
		Complex c=a.complexAdd(b);
		System.out.println("a+b="+c.ToString());
	}

}


Complex类
public class Complex {
	int RealPart;
	int ImaginPart;
	Complex(){
		RealPart=0;
		ImaginPart=0;
	}
	Complex(int r,int i){
		RealPart=r;
		ImaginPart=i;
	}
	Complex complexAdd(Complex a) {
		this.RealPart+=a.RealPart;
		this.ImaginPart+=a.ImaginPart;
		return this;
	}
	String ToString() {
		String str=RealPart+"+"+ImaginPart+"i";
		return str;
	}
}