C++ 复数类编写小练习

1

创建复数类。然后重载流操作运算符，能够执行输入输出（10分）

题目内容：

1. 关于复数：

复数x被定义为二元有序实数对(a,b)，记为z=a+bi,这里a和b是实数，i是虚数单位。在复数a+bi中，a=Re(z)称为实部，b=Im(z)称为虚部。当虚部等于零时，这个复数可以视为实数；当z的虚部不等于零时，实部等于零时，常称z为纯虚数。

复数的四则运算规定为：

    加法法则：(a+bi)+(c+di)=(a+c)+(b+d)i；

    减法法则：(a+bi)－(c+di)=(a－c)+(b－d)i；

    乘法法则：(a+bi)·(c+di)=(ac－bd)+(bc+ad)i；

    除法法则：(a+bi)÷(c+di)=[(ac+bd)/(c²+d²)]+[(bc-ad)/(c²+d²)]i.

 

2. 创建一个类 MyComplex，用来表示复数。

3. 重载流提取运算符 >> ，使之可以读入以下格式的输入(两个数值之间使用空白分隔)，将第一个数值存为复数的实部，将第二个数值存为复数的虚部：

    -1.1  2.0

    +0   -4.5

4. 重载流插入运算符 << ，使之可以将复数输出为如下的格式(实部如果是非负数，则不输出符号位；输出时要包含半角左右小括号)：

   (-1.1+2.0i)

   (0-4.5i)

5. 不可以改动主函数内部的任何表达式或者语句

 

头文件及主函数：

 

1. #include <iostream>

2. int main() {

3.     MyComplex z1, z2;

4.     cin >> z1;

5.     cin >> z2;

6.     cout << z1 << " " << z2;  //z1和z2之间间隔1个空格

7.  

8.     return 0;

9. }

注意1:

两个流操作运算符必须重载为 MyComplex 类的友元函数！

两个流操作运算符必须重载为 MyComplex 类的友元函数！

两个流操作运算符必须重载为 MyComplex 类的友元函数！

注意2: 

输入 -1  -0，输出为 -1-0i

输入-1 0，输出为 -1+0i

输入格式:

输入两个复数。

每个复数均包括由空格分隔的两个浮点数

输入第一个复数后，键入回车，然后继续输入第二个复数

输出格式：

输出两个复数，每个复数占一行；

复数是由小括号包围的形如 (a+bi) 的格式。

小括号必须是半角的！全角括号会撑破你的肚子！

输入样例：

-1.1 2.0

0 -4.5         

输出样例：

(-1.1+2i) (0-4.5i)

以上输出只有1行，行尾没有换行

#include <iostream>
using namespace std;

class MyComplex {
private:
	double real_;
	double image_;
public:

	friend ostream& operator <<(ostream& os, const MyComplex& z) {
		//os << "(" << z.real_ << "+" << z.image_ << "i)";
		os.unsetf(std::ios::showpos);
		os << "(" << z.real_;
		os.setf(std::ios::showpos);
		os << z.image_ << "i)";

		return os;
	}
	
	friend istream& operator >>(istream& is, MyComplex& z) {
		is >> z.real_ >> z.image_;
		return is;
	}

};

int main() {
	MyComplex z1, z2;
	cin >> z1;
	cin >> z2;
	cout << z1 << " " << z2;  //z1和z2之间间隔1个空格
	return 0;
}

1

修改复数类，重载加减法运算符（10分）

 

题目内容：

1. 在本单元作业1的基础上，修改/添加代码，重载四则运算符 +、- 、*、/，使之可以完成相应的运算

2. 在做除法时，如果除数是0，则输出一条信息：“Divisor can not be 0” （注意：请精确复制这段信息，否则即便你的程序逻辑正确，OJ系统仍然会判你失败。输出信息中不包含引号）然后结束程序（调用 exit() 函数），直接退出（注意，传递给操作系统的返回值与main函数正常结束时相同，仍然为0）。判断除数是否为0时，使用if()语句即可

3. 不改动主函数。

 

包含的头文件及主函数：

请勿对主函数内容做任何改变，包括字符串中的空白等。否则，OJ可能不给你分数！

 

 

1. #include <iostream>
2. #include <cstdlib>
3. #include <limits>
4. int main() {
5.     MyComplex z1, z2;
6.     cin >> z1;
7.     cin >> z2;
8.     cout << "z1 + z2 = "      << z1 + z2      << endl;
9.     cout << "z1 - z2 + z1 = " << z1 - z2 + z1 << endl;
10.     cout << "z1 * z2 - z1 = " << z1 * z2 - z1 << endl;
11.     cout << "z1 / z2 + z1 = " << z1 / z2 + z1 << endl;
12.     cout << "z2 - z1 / z1 = " << z2 - z1 / z1;
13.     // GCC及VC编译器在调试模式下会暂停，便于查看运行结果
14. #if ( defined(__DEBUG__) || defined(_DEBUG) )
15.     cin.ignore(numeric_limits<streamsize>::max(), '\n');
16.     cin.get();
17. #endif
18.     return 0;
19. }

输入格式:

输入两个复数。

每个复数均包括由空格分隔的两个浮点数

输入第一个复数后，键入回车，然后继续输入第二个复数

 

输出格式：

单个复数的输出格式参见本单元作业1的输出格式

本题目的输出，请见主函数

 

输入样例：

+100 -0 8.0000001 +040.2

 

输出样例：

z1 + z2 = (108+40.2i)

z1 - z2 + z1 = (192-40.2i)

z1 * z2 - z1 = (700+4020i)

z1 / z2 + z1 = (100.476-2.3928i)

z2 - z1 / z1 = (7+40.2i)

上述输出的第5行尾没有换行符

 

这里注释的一行还有问题

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;

class MyComplex {
private:
	double real_;
	double image_;
public:
	MyComplex() {}
	MyComplex(double real, double image) :real_(real), image_(image) {}
	MyComplex(const MyComplex &z):real_(z.real_),image_(z.image_){}

	friend ostream& operator <<(ostream& os, const MyComplex& z) {
		//os << "(" << z.real_ << "+" << z.image_ << "i)";
		os.unsetf(std::ios::showpos);
		os << "(" << z.real_;
		os.setf(std::ios::showpos);
		os << z.image_ << "i)";

		return os;
	}

	friend istream& operator >>(istream& is, MyComplex& z) {
		is >> z.real_ >> z.image_;
		return is;
	}

	MyComplex operator +(MyComplex& z) {
		return MyComplex(real_ + z.real_, image_ + z.image_);
	}

	MyComplex operator -(MyComplex& z) {
		return MyComplex(real_ - z.real_, image_ - z.image_);
	}

	/*friend MyComplex operator-(MyComplex&z1, MyComplex &z2) {
		return MyComplex(z1.real_ - z2.real_, z1.image_ - z2.image_);
	}*/

	MyComplex operator * (const MyComplex& z) {
		//(a+bi)·(c+di)=(ac－bd)+(bc+ad)i
		return MyComplex(real_*z.real_ - image_ * z.image_,
			image_*z.real_ + real_ * z.image_);
	}

	MyComplex operator / (const MyComplex& z) {
		//(a+bi)/(c+di)=[(ac+bd)/(c²+d²)]+[(bc-ad)/(c²+d²)]i
		if ((z.real_ == 0) && (z.image_ == 0)) {
			cout << "Divisor can not be 0";
			exit(0);
		}
		double length = z.real_*z.real_ + z.image_*z.image_;
		double real = (real_ * z.real_ + image_ * z.image_) / length;
		double image = (image_ * z.real_ - real_ * z.image_) / length;
		return MyComplex(real, image);
		
	}



};

int main() {
	MyComplex z1, z2;
	cin >> z1;
	cin >> z2;
	cout << "z1 + z2 = " << z1 + z2 << endl;
	cout << "z1 - z2 + z1 = " << z1 - z2 + z1 << endl;
	cout << "z1 * z2 - z1 = " << z1 * z2 - z1 << endl;
	cout << "z1 / z2 + z1 = " << z1 / z2 + z1 << endl;
	//cout << "z2 - z1 / z1 = " << z2 - z1 / z1;
	// GCC及VC编译器在调试模式下会暂停，便于查看运行结果
#if ( defined(__DEBUG__) || defined(_DEBUG) )
	cin.ignore(numeric_limits<streamsize>::max(), '\n');
	cin.get();
#endif
	return 0;
}