C++中的复数Complex类

Complex类的成员变量有实部与虚部：

                                       protected: 

                                                       double _real; 

                                                       double _image;

本次将实现在C++中的Complex类的基本函数，包括四个默认成员函数，比较运算符重载函数，赋值运算符重载函数，以及前置++与后置++的重载。

四个默认成员函数是（1）构造函数：在定义对象时初始化成员变量，函数名与类名相同，无返回值（void也不能有），对象实例化时系统自动调用

                                    （2）拷贝构造函数：是一种特殊的构造函数，是对构造函数的重载，用同类对象初始化成员变量

                                    （3）析构函数：函数名是在类名前加~，无参数无返回值，函数作用是做一些清理工作，在对象生命周期结束时系统自动调用

                                    （4）赋值运算符重载：operator+合法的运算符构成运算符重载

下面是编写的代码，在默认成员函数中我加上了一些输出，便于清楚看到成员函数是怎么运行的

#define _CRT_SECURE_NO_WARNINGS 1

#include
using namespace std;

class Complex
{
public:
	Complex(double real = 8.0, double image = 6.0)       //构造函数
		:_real(real)
		, _image(image)
	{
		cout <<" Complex(double real, double image)" << endl;
	}
	Complex(const Complex& d)          //拷贝函数
	{
		cout << "Complex(const Complex& d)" << endl;
		_real = d._real;
		_image = d._image;
	}
	~Complex()       //析构函数
	{
		cout << "~Complex() " << endl;
		_real = 0.0;
		_image = 0.0;
	}
	Complex& operator=(const Complex& d)         //赋值运算符重载
	{
		cout << "=" << endl;
		if (this != &d)
		{
			_real = d._real;
			_image = d._image;
		}
		return *this;
	}
	void Display()const                //打印复数
	{
		cout << "_real:"<< _real;
		cout << "      _image:" << _image << endl;
	}
	
	bool operator==(const Complex& d)             //==
	{
		cout << "==" << endl;
		return this->_real == d._real
			&& this->_image == d._image;
	}
	bool operator!=(const Complex& d)             //!=
	{
		cout << "!=" << endl;
		return this->_real != d._real
			|| this->_image == d._image;
	}
	//复数只有当虚部为0时，即_image=0时，才可以比较大小，这时比较的是实部即_real的大小
	bool operator>(const Complex& d)          //>
	{
		if (this->_image != 0 || d._image != 0)
		{
			cout << "无法比较       " ;
			return false;
		}

		else
		{
			return this->_real > d._real;
		}
	}
	bool operator<(const Complex& d)           //<
	{
		if (this->_image != 0 || d._image != 0)
		{
			cout << "无法比较      ";
			return false;
		}
		else
		{
			return this->_real < d._real;
		}
	}
	bool operator<=(const Complex& d)           //<=
	{
		if (this->_image != 0 || d._image != 0)
		{
			cout << "无法比较      ";
			return false;
		}
		else
		{
			return this->_real <= d._real;
		}
	}
	bool operator>=(const Complex& d)           //>=
	{
		if (this->_image != 0 || d._image != 0)
		{
			cout << "无法比较        ";
			return false;
		}
		else
		{
			return this->_real >= d._real;
		}
	}
	Complex operator+ (const Complex& d)           //+
	{
		cout << "+" << endl;
		Complex ret;
		ret._real = (this->_real + d._real);
		ret._image = (this->_image + d._image);
		return ret;
	}
	Complex& operator+=(const Complex& d)          //+=
	{
		cout << "+=" << endl;
		this->_real += d._real;
		this->_image += d._image;
		return *this;
	}
	Complex& operator++()            //前置++
	{
		cout << "前置++" << endl;
		this->_real += 1;
		return *this;
	}
	Complex operator++(int)         //后置++
	{
		cout << "后置++" << endl;
		Complex tmp(*this);
		this->_real += 1;
		return tmp;
	}


protected:
	double _real;
	double _image;
};

1、测试用例Test（）------测试构造函数，以及==和！=以及+运算符的重载

void Test()
{ 
	Complex d1;
	Complex d2(4.0,6.6);

	d1.Display();
	d2.Display();
	//d1 = d2;
	//d1.Display();
	Complex d3;
	d3 = d1 + d2;
	cout << d1.operator==(d2) << endl;
	cout << d1.operator!=(d2) << endl;
	d3.Display();
}

运行结果：

我们可以看到系统调用函数的顺序，析构函数是清理工作，当生命周期结束时系统自动调用。

2、测试用例Test1（）------------测试+=运算符

void Test1()
{
	Complex d1;
	Complex d2(4.0, 9.6);
	d1.Display();
	d2.Display();
	d1 += d2;
	d1.Display();
	d2.Display();
}

运行结果：

3、测试用例Test2（）---------测试前置++与后置++

void Test2()
{
	Complex d1;
	Complex d2(0, 0);
	d2 = ++d1;
	d2.Display();
	d1.Display();
	Complex d3(1.0, 2.0);
	d3 = d1++;
	d3.Display();
	d1.Display();

}

运行结果：

4、测试用例Test3（）--------测试>/>=/

void Test3()
{
	Complex d1(7,0);
	Complex d2(6, 0);
	Complex d3;
	Complex d4(6, 0);
	cout << d1.operator>(d2) << endl;
	cout << d1.operator<(d2) << endl;
	cout << d3.operator<=(d4) << endl;
	cout << d2.operator>=(d4) << endl;
}

运行结果：