C++ 实数类

最新推荐文章于 2024-06-12 20:05:38 发布

Rps

最新推荐文章于 2024-06-12 20:05:38 发布

阅读量2.1k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： C++ 模版 C++11

本文链接：https://blog.youkuaiyun.com/rkexy/article/details/82866345

本文介绍了一个自定义的C++实数类，该类支持基本的四则运算和比较操作。虽然目前尚未实现整数或小数转换以及无限循环小数转分数的功能，但作者强调了模版在实现过程中的重要作用，并分享了学习模版的心得。代码中已修复了operator=的自我赋值问题和小数转分数可能导致的整数溢出问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是一堆我自己写完都怀疑人生的代码。
或许我见识太少了吧……

实现一个实数类。这个类也可以看作是分数类。实现了基本的四则运算和比较。另外，与整数或小数的转换还没有实现，无限循环小数转分数也暂时没有实现。但我早晚会写的。。。
咕咕咕。
这里的重头戏是模版。
啊……模版，我边学边卖，才知道模版还可以这么玩。
这次只有一个文件……
来体会一下来自C++的恐惧吧！

注意：以下代码没有经过严谨测试及性能优化。

BUGFIX:
1. 修复operator=不能对自身影响的BUG；（2018.10.10）
2.修复小数转分数时，造成整数溢出的BUG；（2018.10.10）

Rational.h

#pragma once
#include "stdinc.h"

namespace Lunacia
{
    
    
	class __Rational {
    
    };

	template<typename NumT = int>
	class Rational final : public __Rational
	{
    
    
	public:
		Rational();

		template<typename NumT2>
		Rational(const Rational<NumT2>& ra); 

		Rational(NumT numer, NumT denom);
		Rational(NumT numer, NumT denom, bool isDenomFixed);
		~Rational();

	public:
		static NumT Gcd(NumT a, NumT b);
		static NumT Lcm(NumT a, NumT b);

		static bool IsEven(NumT num);
		static NumT GetSymbol(NumT num);

		static bool IsEqualFloating(long double a, long double b);

		void SetDenomFixed(bool isFix);
		bool GetDenomFixed() const;

		void GetRationalString(std::string& __out resStr) const;
		void GetRationalString(std::wstring& __out resStr) const;

	public:
		///operator+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		template<typename ParamT,
			typename  std::enable_if < std::is_integral <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator +(const ParamT rRational) const;

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator +(const ParamT& rRational) const;

		Rational<NumT> operator +(const Rational& rRational) const;

		///operator-----------------------------------------------------------------------
		template<typename ParamT,
			typename  std::enable_if < std::is_integral <ParamT> ::value, ParamT > ::type * = nullptr>
		Rational<NumT> operator -(const ParamT& rRational) const;

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator -(const ParamT& rRational) const;

		Rational<NumT> operator -(const Rational& rRational) const;

		///operator******************************************************
		template<typename ParamT,
			typename  std::enable_if < std::is_integral <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator *(const ParamT& rRational) const;

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator *(const ParamT& rRational) const;

		Rational<NumT> operator *(const Rational& rRational) const;
		
		///operator///////////////////////////////////////////////////////
		template<typename ParamT,
			typename  std::enable_if < std::is_integral <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator /(const ParamT& rRational) const;

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator /(const ParamT& rRational) const;

		Rational<NumT> operator /(const Rational& rRational) const;

		///operator=======================================================
		template<typename ParamT,
			typename  std::enable_if < std::is_integral <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator =(const ParamT& rRational);

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			Rational<NumT> operator =(const ParamT& rRational);

		Rational<NumT> operator =(const Rational& rRational);

		///operator== == == == == == == == == == == == == == == == == == == == == == ==
		template<typename ParamT,
			typename  std::enable_if < 
				std::is_integral <ParamT> ::value || 
					std::is_base_of<__Rational, ParamT>::value,
				ParamT 
			> ::type * = nullptr>
			bool operator ==(const ParamT& rRational) const;

		template<typename ParamT,
			typename  std::enable_if < std::is_floating_point <ParamT> ::value, ParamT > ::type * = nullptr>
			bool operator ==(const ParamT& rRational) const;
		
		///operator!= != != != != != != != != != != != != != != != != != != != != != != != != != != != != 
		template<typename ParamT,
			typename  std::enable_if <
				std::is_integral <ParamT> ::value ||
					std::is_floating_point <ParamT> ::value||
					std::is_base_of<__Rational, ParamT>::value,
				ParamT
			> ::type * = nullptr>
			bool operator !=(const ParamT& rRational) const;

		///operator>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
		template<typename ParamT,
			typename  std::enable_if <
					std::is_integral <ParamT> ::value ||
					std::is_floating_point <ParamT> ::value ||
					std::is_base_of<__Rational, ParamT>::value,
				ParamT
			> ::type * = nullptr>
			bool operator >(const ParamT& rRational) const;

		///operator <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
		template<typename ParamT,
			typename  std::enable_if <
				std::is_integral <ParamT> ::value ||
					std::is_floating_point <ParamT> ::value ||
					std::is_base_of<__Rational, ParamT>::value,
				ParamT
			> ::type * = nullptr>
		bool operator <(const ParamT& rRational) const ;

		///operator >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= >= 
		template<typename ParamT,
			typename  std::enable_if <
				std::is_integral <ParamT> ::value ||
					std::is_floating_point <ParamT> ::value ||
					std::is_base_of<__Rational, ParamT>::value,
				ParamT> ::type * = nullptr>
		bool operator >=(const ParamT& rRational);

		///operator <= <= <= <= <= <= <= <= <= <= <