C++实现一个分数计算器

打卡C++学习的n天，一起进步吧

文章目录

目录

文章目录

前言

一、什么是运算符重载：

二、输入输出流

核心代码部分

总结

---

---

前言

       传统运算符只能实现确定类型之间的运算，而无法实现用户自定义类型的运算，因此

需要实现对运算符的重载，其本质是函数重载；

         C++运算符重载是C++的一大亮点，它可以实现类之间的运算，以及用户自定义类型之间的运算，例如两个复数的加减乘除运算，本次实现一个分数运算的计算器；

---

一、什么是运算符重载：

以复数的运算为例，要实现复数之间的运算，仅通过系统定义的"+","-"等运算是无法实现的，

因此就有

#include<iostream>

using namespace std;
//在这里定义一个复数类
class Complex
{
private:
	int real;//复数的实数部分
	int imeag;//复数的虚部部分;
public:
	Complex(){}
	Complex(int r, int i)
	{
		this->real = r;
		this->imeag = i;
	}
	void print()
	{
		if (this->imeag >= 0)
		{
			cout << this->real << "+"
				<< this->imeag<<"i"<<endl;
		}
		else
		{
			cout << this->real 
				<< this->imeag << "i" << endl;

		}
	}
	Complex  operator+(Complex c1);
	//在此是一个复数加法的运算重载函数，
	//运算符重载的基本格式
	/*
	返回类型  operator需要重载的运算符(形参列表）
	{函数体}

	*/
	friend Complex  operator-(Complex c1,Complex c2);

};
//类外实现这个函数
//另外值得注意的是因为这个函数是成员函数，所以形参列表
//里只有一个参数
Complex Complex::operator+(Complex c1)
{
	this->real = this->real + c1.real;
	this->imeag = this->imeag + this->imeag;
	return  *this;
}
//这里是一个友元函数，他的形参可以是两个甚至多个
Complex  operator-(Complex c1,Complex c2)
{
	Complex temp;
	temp.real = c1.real - c2.real;
	temp.imeag = c1.imeag - c2.imeag;
	return  temp;
}
int main()
{
	Complex c1(1, 2), c2(3, 4),c3;
	c1 = c1 + c2;
	//这里属于隐式调用
	c1.print();
	c1.operator+(c2);
	//显式调用
	c1.print();
	system("pause");
	return 0;
}

二、输入输出流

思考这样一个问题，如果要输入一个分数，例如"3/4", 在C++中我们应该怎么做，更进一步，

如何像输入一个整数一样输入一个分数呢，下面我们引入输入输出流的概念；

对于用户

自己定义的数据类型的输入 / 输出，可以通过重载运算符“ >> ”

和“ << ” 实现；

重载输出运算符“ << ”

 输出运算符“ <<” ，又称插入运算符，定义其重载函数的格式如下：

ostream &operator<<(ostream &out, class_name& obj)//class_name为类名
{
out<<obj.data1;
out<<obj.data2;

out<<obj.datan;
return out;
}

同理输入”>>"运算符也可以重载

istream &operator>>(istream &in, class_name& obj)
{
in>>obj.data1;
in>>obj.data2;

in>>obj.datan;
return in;
}

核心代码部分

基于上述知识总结，下面就可以完成一个分数计算器了；

下面是Fraction.h的内容：

#include<iostream>

using namespace std;
//引入输入输出流的概念；

class  Fraction
{
private:
	int  numer, danumer;
public:
	Fraction()
	{
		this->numer = 0;
		this->danumer = 1;

	}
	Fraction(int n, int m)
	{
		this->numer = n;
		this->danumer = m;


	}
	~Fraction()
	{
	}
	//重载运算符;
	void  operator >> (Fraction  f);

	void operator << (Fraction  f);

	//约分函数;
	void  Sharing();
	friend istream& operator>>(istream& in, Fraction& obj)
	{
		char ch = 'f';
		cin >> obj.numer >> ch >> obj.danumer;
		return in;
	}
	friend ostream& operator<<(ostream& out, Fraction& obj)
	{
		char ch = '/';
		cout << obj.numer << ch << obj.danumer << endl;
		return out;

	}
	friend Fraction  operator+(Fraction obj1, Fraction obj2);
	friend Fraction  operator-(Fraction& obj1, Fraction& obj2);
	friend Fraction  operator*(Fraction obj1, Fraction obj2);
	friend Fraction  operator%(Fraction obj1, Fraction obj2);
	void print()
	{
		cout << this->numer << '/' << this->danumer << endl;

	}
	
};

Fraction  operator+(Fraction obj1, Fraction obj2)
{
	Fraction f;
	f.numer = obj1.numer * obj2.danumer + obj1.danumer * obj2.numer;
	f.danumer = obj1.danumer * obj2.danumer;
	return f;

}
Fraction  operator-(Fraction& obj1, Fraction& obj2)
{
	Fraction f;
	f.numer= obj1.numer * obj2.danumer -obj1.danumer * obj2.numer;
	f.danumer = obj1.danumer * obj2.danumer;
	obj1.Sharing();
	obj2.Sharing();

	return f;

}
Fraction  operator*(Fraction obj1, Fraction obj2)
{
	Fraction f;
	f.numer = obj1.numer * obj2.danumer;

	f.danumer = obj1.danumer * obj2.danumer;
	return f;
}
Fraction  operator%(Fraction obj1, Fraction obj2)
{
	Fraction  f1, f2;
	f2.danumer = obj2.numer;
	f2.numer = obj2.danumer;
	f1 = f2 * obj1;
	return f1;


}
void  Fraction::operator >> (Fraction  f)
{
	char  ch = '1';
	int n = 0, m = 1;
	
	cin >> n >> ch >> m;
	if (m == 0)
	{
		cout << "input  Error" << endl;
		cout << "please input again" << endl;
		cin >> m;


	}

	this->numer = n;
	this->numer = m;

	

}
void  Fraction::operator << (Fraction  f)
{

	cout << this->numer << "/" << this->danumer;

}
void  Fraction::Sharing()
{
	int n = this->numer;
	int m = this->danumer;
	int gcd = 0;

	for (int i = n;i >= 1; i--)
	{
		if (n % i == 0 && m % i == 0)
		{
			gcd = i;

			break;

		}
	}
	this->numer /= gcd;
	this->danumer /= gcd;


	/*cout << gcd << endl;*/
}

下面是main.cpp的内容

#include<iostream>

#include"Fraction.h"
using namespace  std;

int main()
{

	Fraction  f1, f2, f3;

	//f1.Sharing();
	//f1.operator<<(f1);
	char  ch = 'f';
	cin >> f1 >> ch >> f2;

	/*cin >> f1 >> ch>>
	f3 = f1 + f2;
	f3.Sharing();
	f3.print();*/
	if (ch == '+')
	{
		f3 = f1 + f2;
		f3.Sharing();

	}
	else if (ch == '-')
	{
		f3 = f1 - f2;
		f3.Sharing();
		cout << f1 << ch << f2 << f3 << endl;

	}
	else if (ch == '*')
	{
		f3 = f1 * f2;
		f3.Sharing();

	}
	else if (ch == '%')
	{
		f3 = f1 % f2;
		f3.Sharing();

	}

	/*cout << f3;*/


	//f1.Sharing();
	///*f1.print();*/
	//cout << f1 << endl;
	system("pause");
	return 0;

}

---

总结

在这个计算器里面，用到了运算符重载，输入输出流的概念，小编希望读者们好好理解学习啊，

同时小编也是小白，做的不好的地方，请多多见谅。