C++实现一个分数模板类的头文件

于 2023-07-21 14:14:32 发布
阅读量126 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/obertys/article/details/131850412
版权

使用C++语言自己实现了一个分数类。
支持分数加减乘除四则运算，输入输出操作，分数大小比较等基本功能。支持用模板自定义表示分子和分母的整数类型。
语法严谨，缩进适当，注释简洁。

/** 有理数模板类实现文件 Rational.h
 ** @obertys V5.0 2023/07/21
 **
 ** 有理数实现为整数与整数之比，如1\2、-9\4等
 ** 支持有理数加减乘除四则运算，输入输出操作，有理数大小比较等基本功能
 ** 注意在输入输出中，分数线表示为反斜杠'\\'
 **
 ** 模板类型integer必须有符号（支持负数）且支持基本运算，不建议将浮点数作为模板类型参数
 **/
#include<iostream>

/*友元模板函数前置声明*/
template<typename integer> class Rational;
template<typename integer> std::istream& operator>>(std::istream& input,Rational<integer>& fraction);
template<typename integer> std::ostream& operator<<(std::ostream& output,const Rational<integer>& fraction);
template<typename integer> std::string& operator>>(std::string& input,Rational<integer>& fraction);
template<typename integer> std::string& operator<<(std::string& output,const Rational<integer>& fraction);
template<typename integer> bool operator==(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> bool operator<(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> bool operator>(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> Rational<integer> operator+(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> Rational<integer> operator-(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> Rational<integer> operator*(const Rational<integer>& fractionA,const Rational<integer>& fractionB);
template<typename integer> Rational<integer> operator/(const Rational<integer>& fractionA,const Rational<integer>& fractionB);

/*有理数模板类定义*/
template<typename integer>
class Rational
{
public:
	/*异常类型*/
	struct DivideByZero {};	//除以0异常类

	/*流输入输出运算符*/
	/*可输入一个整数或一个整数除以另一个整数的形式，输入的正号或负号应总是在第一个整数之前*/
	/*输入示例：-1 0 25 8\3 -9\51*/
	/*输出为一个整数，或一个整数除以另一个整数的形式*/
	/*输出示例：-1 0 25 8\3 -9\51*/
	friend std::istream& operator>> <>(std::istream& input,Rational& fraction);
	friend std::ostream& operator<< <>(std::ostream& output,const Rational& fraction);

	/*字符串输入输出运算符（流输入输出的字符串版本）*/
	friend std::string& operator>> <>(std::string& input,Rational& fraction);
	friend std::string& operator<< <>(std::string& output,const Rational& fraction);

	/*大小比较运算符*/
	friend bool operator== <>(const Rational& fractionA,const Rational& fractionB);
	friend bool operator==(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA==Rational(fractionB);
	}
	friend bool operator==(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)==fractionB;
	}

	friend bool operator!=(const Rational& fractionA,const Rational& fractionB)
	{
		return !(fractionA==fractionB);
	}
	friend bool operator!=(const integer& fractionA,const Rational& fractionB)
	{
		return !(fractionA==fractionB);
	}
	friend bool operator!=(const Rational& fractionA,const integer& fractionB)
	{
		return !(fractionA==fractionB);
	}

	friend bool operator< <>(const Rational& fractionA,const Rational& fractionB);
	friend bool operator<(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)<fractionB;
	}
	friend bool operator<(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA<Rational(fractionB);
	}

	friend bool operator<=(const Rational& fractionA,const Rational& fractionB)
	{
		return !(fractionA>fractionB);
	}
	friend bool operator<=(const integer& fractionA,const Rational& fractionB)
	{
		return !(fractionA>fractionB);
	}
	friend bool operator<=(const Rational& fractionA,const integer& fractionB)
	{
		return !(fractionA>fractionB);
	}

	friend bool operator> <>(const Rational& fractionA,const Rational& fractionB);
	friend bool operator>(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)>fractionB;
	}
	friend bool operator>(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA>Rational(fractionB);
	}

	friend bool operator>=(const Rational& fractionA,const Rational& fractionB)
	{
		return !(fractionA<fractionB);
	}
	friend bool operator>=(const integer& fractionA,const Rational& fractionB)
	{
		return !(fractionA<fractionB);
	}
	friend bool operator>=(const Rational& fractionA,const integer& fractionB)
	{
		return !(fractionA<fractionB);
	}

	/*一元运算符+-*/
	friend Rational operator+(const Rational& fraction)
	{
		return fraction;
	}
	friend Rational operator-(const Rational& fraction)
	{
		return Rational(-fraction.numerator,fraction.denominator);
	}

	/*二元运算符+，-，*，/*/
	friend Rational operator+ <>(const Rational& fractionA,const Rational& fractionB);
	friend Rational operator- <>(const Rational& fractionA,const Rational& fractionB);
	friend Rational operator* <>(const Rational& fractionA,const Rational& fractionB);
	friend Rational operator/ <>(const Rational& fractionA,const Rational& fractionB);

	friend Rational operator+(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)+fractionB;
	}
	friend Rational operator-(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)-fractionB;
	}
	friend Rational operator*(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)*fractionB;
	}
	friend Rational operator/(const integer& fractionA,const Rational& fractionB)
	{
		return Rational(fractionA)/fractionB;
	}
	friend Rational operator+(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA+Rational(fractionB);
	}
	friend Rational operator-(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA-Rational(fractionB);
	}
	friend Rational operator*(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA*Rational(fractionB);
	}
	friend Rational operator/(const Rational& fractionA,const integer& fractionB)
	{
		return fractionA/Rational(fractionB);
	}

	/*构造函数*/
	Rational(void):numerator(0),denominator(1) {}	//有理数0
	Rational(integer Numberator,integer Denominator);	//有理数Numberator/Denominator

	/*转换函数*/
	Rational(integer wholeNumber):numerator(wholeNumber),denominator(1) {}	//有理数wholeNumber
	template<typename T> T toDecimal(void) const	//返回分数的小数形式
	{
		return static_cast<T>(numerator)/static_cast<T>(denominator);
	}

	/*取值/赋值函数*/
	integer Numerator(void) const	//返回分子
	{
		return numerator;
	}
	integer Denominator(void) const	//返回分母
	{
		return denominator;
	}
	void Numerator(integer Numerator_);	//设置分子
	void Denominator(integer Denominator_);	//设置分母

	/*一元运算符+=，-=，*=，/=*/
	void operator+=(const Rational& fraction)
	{
		*this=*this+fraction;
		return;
	}
	void operator-=(const Rational& fraction)
	{
		*this=*this-fraction;
		return;
	}
	void operator*=(const Rational& fraction)
	{
		*this=*this*fraction;
		return;
	}
	void operator/=(const Rational& fraction)
	{
		if(fraction==0)
			throw DivideByZero();
		*this=*this/fraction;
		return;
	}

	void operator+=(const integer& fraction)
	{
		*this=*this+fraction;
		return;
	}
	void operator-=(const integer& fraction)
	{
		*this=*this-fraction;
		return;
	}
	void operator*=(const integer& fraction)
	{
		*this=*this*fraction;
		return;
	}
	void operator/=(const integer& fraction)
	{
		if(fraction==0)
			throw DivideByZero();
		*this=*this/fraction;
		return;
	}

private:
	/*数据变量*/
	integer numerator;	//分子
	integer denominator;	//分母

	/*辅助成员函数*/
	void reduction(void);	//约分

};

/*辅助函数*/
template<typename integer> static integer gcd_lcm(register integer x,register integer y,char op)	//op为'G'返回x,y最大公约数,为'L'返回x,y最小公倍数
{
	//x的符号,y的符号,gcd的符号,lcm的符号:正正正正,负负负负,正负正负,负正负正
	integer temp=x*y,z;
	while(y)	//辗转反除
	{
		z=x%y;
		x=y;
		y=z;
	}
	switch(op)
	{
	case 'G':
		return x;
	case 'L':
		return temp/x;
	default:
		return 0;
	}
}
template<typename integer> inline char sing(integer a)	//返回a的符号
{
	return a<0?'-':'+';
}
template<typename integer> inline integer abs(integer a)	//返回a的绝对值
{
	return a<0?-a:a;
}

/*有理数模板类成员函数、友元函数实现*/
template<typename integer> Rational<integer>::Rational(integer Numberator,integer Denominator):numerator(Numberator),denominator(Denominator)	//有理数Numberator/Denominator
{
	reduction();
}

template<typename integer> void Rational<integer>::reduction(void)	//约分
{
	integer num_gcd=gcd_lcm(numerator,denominator,'G');	//求最大公约数
	numerator/=num_gcd,denominator/=num_gcd;	//约分赋值
	if(denominator<0)
		numerator=-numerator,denominator=-denominator;
	else if(denominator==0)
		throw DivideByZero();
}
template<typename integer> void Rational<integer>::Numerator(integer Numerator_)	//设置分子
{
	numerator=Numerator_;
	return;
}
template<typename integer> void Rational<integer>::Denominator(integer Denominator_)	//设置分母
{
	if(Denominator_<0)
		numerator=-numerator,denominator=-Denominator_;
	else
		denominator=Denominator_;
	return;
}

template<typename integer> std::istream& operator>>(std::istream& input,Rational<integer>& fraction)	//流输入
{
	input>>fraction.numerator;
	if(input.peek()=='\\')
	{
		input.ignore(1);
		input>>fraction.denominator;
		fraction.reduction();
	}
	else
		fraction.denominator=1;
	return input;
}
template<typename integer> std::ostream& operator<<(std::ostream& output,const Rational<integer>& fraction)	//流输出
{
	output<<fraction.numerator;
	if(fraction.denominator!=1)
		output<<'\\'<<fraction.denominator;
	return output;
}
template<typename integer> std::string& operator>>(std::string& input,Rational<integer>& fraction)	//字符串输入
{
	char* ptr;
	const char* input_str=input.c_str();
	fraction.numerator=strtoll(input_str,&ptr,10);
	if(*ptr=='\\')
	{
		fraction.denominator=strtoll(ptr+1,&ptr,10);
		fraction.reduction();
	}
	else
		fraction.denominator=1;
	input.erase(0,ptr-input_str);	//擦除字符串中提取的分数
	return input;
}
template<typename integer> std::string& operator<<(std::string& output,const Rational<integer>& fraction)	//字符串输出
{
	output+=to_string(fraction.numerator);	//后缀分子至字符串
	if(fraction.denominator!=1)
		output+='\\'+to_string(fraction.denominator);
	return output;
}

template<typename integer> bool operator==(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	return fractionA.numerator*fractionB.denominator==fractionA.denominator*fractionB.numerator;
}
template<typename integer> bool operator<(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	return fractionA.numerator*fractionB.denominator<fractionA.denominator*fractionB.numerator;
}
template<typename integer> bool operator>(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	return fractionA.numerator*fractionB.denominator>fractionA.denominator*fractionB.numerator;
}

template<typename integer> Rational<integer> operator+(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	Rational<integer> ret;	//A+B
	ret.denominator=gcd_lcm(fractionA.denominator,fractionB.denominator,'L');	//分母为最小公倍数
	ret.numerator=fractionA.numerator*(ret.denominator/fractionA.denominator)+fractionB.numerator*(ret.denominator/fractionB.denominator);	//分子为A,B分子通分后的和
	ret.reduction();	//约分
	return ret;
}
template<typename integer> Rational<integer> operator-(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	Rational<integer> ret;	//A-B
	ret.denominator=gcd_lcm(fractionA.denominator,fractionB.denominator,'L');	//分母为最小公倍数
	ret.numerator=fractionA.numerator*(ret.denominator/fractionA.denominator)-fractionB.numerator*(ret.denominator/fractionB.denominator);	//分子为A,B分子通分后的差
	ret.reduction();	//约分
	return ret;
}
template<typename integer> Rational<integer> operator*(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	Rational<integer> ret;
	Rational<integer> A_temp(fractionA.numerator,fractionB.denominator);
	Rational<integer> B_temp(fractionB.numerator,fractionA.denominator);
	ret.numerator=A_temp.numerator*B_temp.numerator;	//分子相乘得分子
	ret.denominator=A_temp.denominator*B_temp.denominator;	//分母相乘得分母
	return ret;
}
template<typename integer> Rational<integer> operator/(const Rational<integer>& fractionA,const Rational<integer>& fractionB)
{
	Rational<integer> B_temp(fractionB.denominator,fractionB.numerator);	//A/B=A*(1/B);
	if(B_temp.denominator==0)	//除数为0
		throw typename Rational<integer>::DivideByZero();
	return fractionA*B_temp;
}
obertys
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
template模板及模板类的实例化
thedays_withyou的博客
03-05 1601
模板template 通常，当我们调用一个函数时，编译器只需要掌握函数的声明。 类似的，当我们使用一个类类型的对象时，类定义必须是可用的，但成员函数的定义不必已经出现。 因此我们将类定义和函数声明放在头文件中，而普通函数和类的成员函数的定义放在源文件中。 模板则不同： 为了生成一个实例化版本，编译器需要掌握函数模板或类模板成员函数的定义。因此，与非模板
将模板类写在头文件里
lsaejn的专栏
11-22 1077
如果要将声明和实现，分开，你需要这么做 //MyClass.h template class MyClass { public: MyClass(T x); ~MyClass(); private: T x; }; //MyClass.cpp template MyClass::MyClass(T x) { } template MyClass::~MyClass(
Ｃ++ 分数运算（类+构造）
hhhertzzz的博客
04-11 4795
题目描述 用C++定义和实现一个分数类，并根据要求完成分数对象的运用 分数类包含分子和分母两个属性，操作包括 各属性的get方法 构造函数，初始化分子分母 相加运算，该运算接收两个分数对象的分子和分母，然后进行分数相加，结果保存在自己的分子和分母中，运算规则为：假设当前分数为A0/B0，接收两个分数A1/B1和A2/B2，相加结果，A0=A1×B2+ A2×B1，B0=B1×B2 相乘运算，该...
课程设计 分数的加减乘-- c++实现
m0_57006708的博客
07-12 629
【问题描述】 用分数形式表示的有理数类如下(C++语言描述):class Rational{ private: int x,y; public: Rational(int a=1,int b=1); Rational Add(Rational &r); Rational Sub(Rational &r); Rational Mul(Rational &r); Rational Div(Rational &r); Rational operator+(Rational .
模板头文件、源文件
Jack Zheng's Blog
04-04 1066
当模板遇见.h和.cpp的错误分析 头文件 //first.h template<typename T> void FUN(T); 源文件 #include"first.h" template<typename T> void FUN(T parameter) { cout << parameter << endl; } 以上头文件中声明了一个...
format:一个简单的头文件 C++11 std
07-05
一个简单的头文件 C++11 std::string 格式化程序 用法： std::string test = util::Format( " This is a nice string with numbers {0} and strings {1} nicely formatted " , 123 , " hello " ); std::string test...
memset头文件c++版
05-02
memset头文件 c++版
分数类 c++代码 头文件
06-27
设计该分数类实现分数之间的基础运算，该类的编写用到了类模板和函数模板知识，该类实现了分数之间的加减乘除运算，重载了+、-、*、/...包含一个分数类的头文件和该类的实现文件。 希望该资源能给您解决问题提供思路。
一个c++只包括头文件的HTTP / HTTPS服务器和客户端实现最新代码
04-20
一个c++只包括头文件的HTTP / HTTPS服务器和客户端实现最新代码一个c++只包括头文件的HTTP / HTTPS服务器和客户端实现最新代码一个c++只包括头文件的HTTP / HTTPS服务器和客户端实现最新代码一个c++只包括头文件的...
C++的头文件和实现文件详解
09-03
主要介绍了C++的头文件和实现文件详解的相关资料,需要的朋友可以参考下
C++模板类/函数，将头文件与源文件分离
热门推荐
游行天涯
09-18 15万+
C++泛型编程 将包含模板的源文件与头文件分开 关键在于模板显式实例化。 解决方案 模板函数分离源文件 按一般方式编写.h和.cpp文件，但注意添加template <typename T>的声明； 在.cpp文件末尾，添加模板显式实例化代码，如： // 显式实例化，注意，`template`之后没有`<>`，若添加则会报错！ // 每种将被使用的类型，均需要进行显式实例化 template void A::show(int &&); template voi
C++的模板为什么要在头文件(.h)中实现？
onlysingleboy的专栏
07-18 1万+
今天是个科普文：C++的模板为什么要在头文件(.h)中实现？ 模板的用途 这个事情其实我没什么发言权，实话实说，我写模板比较少。对于模板的重要性，也是最近才感觉到。至于模板的重要性，这里也不多说，自己悟。 模板编写 这里就举个函数模板的例子(我们把实现放在.cpp的错误例子)： lp_max.h template T max(cons
实现C++模板类头文件和实现文件分离的方法
big_bit的博客
09-07 6345
如何实现C++模板类头文件和实现文件分离，这个问题和编译器有关。 引用>里的观点：1）标准C++为编译模板代码定义了两种模型：“包含”模型和“分别编译”模型。2）所有编译器都支持“包含”模型，某些编译器支持“分别编译”模型。 问题的提出：（帖子在：http://topic.csdn.net/u/20101215/15/f4f270f2-f0f9-4c5f-8765-1bfde2aeeb
C++中模板以及模板实例化都放在头文件
l15799033407的博客
09-22 1707
前言 根据之前的习惯，我们一般会把一个函数的声明放在.h文件中，把函数的实现放在.cpp文件中，但是涉及到模板时，这种组织方式会报错。 先放结论：涉及到模板和模板特例化时，我们一般将模板和模板特例化一起放在对应的.h文件中。 问题的产生 通过下例来说明问题。例如在array.h文件中有模板类array： // array.h template <typename T, int SIZE> class array { T data_[SIZE]; array (const...
C++模板类头文件和实现文件分离的方法
09-06 4620
如何实现C++模板类头文件和实现文件分离，这个问题和编译器有关。 引用>里的观点：1）标准C++为编译模板代码定义了两种模型：“包含”模型和“分别编译”模型。2）所有编译器都支持“包含”模型，某些编译器支持“分别编译”模型。 第一种方法：按C++primer中的“包含”模型，在定义模板类的头文件中的末行用语句：#include "template_compile.cpp" 在类模
C++ 模板类与头文件
Keep Fighting!
08-04 3218
今天将模板类函数分成了声明和定义两个文件： 模板类的声明： #pragma once #ifndef FIND_ITEM #define FIND_TIEM template <typename elemType> const elemType* find_item(const elemType* first, const elemType* last, const elem...
C++模板类代码只能写在头文件？
jinzeyu_cn的博客
05-17 1万+
这个问题，实际上我几年前就遇到了。最近写个模板类玩的时候，再次遇到。  当我非常仔细的将定义和实现分开，在头文件中保留了最少的依赖后，一切就绪.cpp单独编过。但是当使用的时候，就会报告所有的函数调用都没有实现。按常规.h/.cpp而言这是不可能的。但是模板类就是这么独特。简单说说他的原因，也备自己将来遗忘：  从语法角度而言，是没有强制要求说模板代码的声明和实现不可以分开。那么当分离的声明和实现写
C++实现模板类头文件和实现文件分离的方法
Linkai12138的博客
04-19 2389
最近在学习类模板，按照书上说的代码敲了，发现运行不了，去查了之后发现可以这样解决： 参考文章：参考文章 在测试文件中（含有main函数的文件）中将 模板类的实现文件包含进来，即将 .cpp 文件包含进来，而不是将 .h 文件包含进来。 具体案例如下：（在vs2017上编译通过，可以运行） Store.h 文件： #pragma once #include <iostream>...
c++头文件定义模板类，cpp文件实现函数功能
最新发布
06-03
当我们需要将模板类的定义和实现分离到不同的文件中时，可以将模板类的声明放在一个头文件中，将模板类的实现放在一个cpp文件中。 假设我们有一个模板类`MyClass`的声明： ```c++ // MyClass.h #pragma once ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值