技術標籤：CAndC++c++演算法類

實驗要求

編寫一個表示有理數的類Rational。（有理數就是分數，包含分子與分母，均為整數）。要求：

1. 1. 定義一個名稱空間Numeric，在該空間中定義類Rational;
   2. 編寫預設建構函式，構造一個有理數0;
   3. 編寫帶引數列表的建構函式Rational (int, int )，要求使用初始化列表；
   4. 編寫複製建構函式；
   5. 編寫賦值操作=；
   6. 編寫四個友元函式add、sub、mul、div，對兩個Rational物件表示的有理數分別進行相加、相減、相乘、相除運算；（例：Rational x(1,2),y(1,3);分別表示有理數 ，則Rational z = add(x,y);之後，z表示
      ）
   7. 過載上述四個函式，實現有理數與整數的相加、相減、相乘、相除運算；（例：Rational x(1,2);表示有理數12 ，則Rational z = add(x,1)，之後，z表示 ）
   8. 編寫成員函式getValue()，返回用浮點數表示的有理數，要求寫成常函式。（例：Rational x(1,2);表示有理數12 ，則x.getValue()返回0.5）
   9. 編寫友元函式lessThan，比較兩個有理數的大小，返回bool型別。（例：Rational x(1,2),y(1,3);則bool b = lessThan(x,y);之後b為false）
   10. 編寫main函式，使用using namespace Numeric;來訪問Numeric::Rational類。編寫程式碼測試Rational類。
   11. 在main函式中，隨機生成10個有理數，形成一個有理數陣列，並利用lessThan函式以及任意一種排序演算法，對這10個有理數進行從小到大排序，輸出排序結果。

注：1）上述友元函式都定義在Rational空間；

2）隨機數通過std::rand()函式生成，可以呼叫std::srand(time(0)); 來設定隨機數種子。

程式碼

主函式的實現

//main.cpp
#include <iostream>
#include "Rational.h"
using namespace std;
using namespace Numeric;
#include<random>
#include<stdlib.h>
#include<time.h>

int main()
{
	FourOpera FourOpera;
	lessThan lessThan;
	//除錯程式碼
	Rational x(8, 6);
	Rational y(16, 6);
	Rational z = FourOpera.add(x, y);

	z.ReducFac();
	cout << "測試結果為:" << endl;
	cout << z.getmole() <<"      "<< z.getdenom() << "      " << z.getValue() << endl;
	
	//陣列
	srand((unsigned)time(0));
	Rational ra[10];
	for (int i = 0; i < 10; i++) {
		ra[i] = Rational(rand(), rand());
		ra[i].ReducFac();
	}
	for (int i = 0; i < 10; i++) {
		for (int j = i; j < 10; j++) {
			if (lessThan.CompSize(ra[i], ra[j]) == true) {
				Rational ce;
				ce = ra[i];
				ra[i] = ra[j];
				ra[j] = ce;
			}
		}
	}
	cout << "輸出結果為:" << endl;
	for (int i = 0; i < 10; i++) {
		cout << ra[i].getValue() << endl;
	}
}
 

Rational標頭檔案，這裡寫的不規範，將函式宣告和操作都放在標頭檔案裡面了，僅供參考

//Rational.h
#ifndef _RATIONAL_
#define _RATIONAL_
#include<cmath>
namespace Numeric {
	class Rational {
	private:
		int mole, denom;//分子分母
		friend class FourOpera;
		friend class lessThan;
	public:
		Rational():mole(1),denom(1){}
		Rational(int _mole, int _denom) {
			mole = _mole;
			denom = _denom;
		}
		Rational(const Rational& Ra) {
			if (this != &Ra) {
				this->mole = Ra.mole;
				this->denom = Ra.denom;
			}
		}
		Rational& operator=(const Rational& Ra) {
			if (this != &Ra) {
				this->mole = Ra.mole;
				this->denom = Ra.denom;
			}
			return *this;
		}
		int getmole() { return mole; }
		int getdenom() { return denom; }
		double getValue() { return float(this->mole) / float(this->denom); }
		//轉化最簡
		int min(int x, int y) {
			if (x > y)return y;
			else return x;
		}
		void ReducFac() {
			int index = min(abs(mole), abs(denom));
			for (int i = 1; i <= index; i++) {
				if (abs(mole) % i == 0 && abs(denom) % i == 0) {
					mole = mole / i;
					denom = denom / i;
				}
			}
		}
	};
	class FourOpera {
	private:
		
	public:
		Rational add(const Rational x,const Rational y) {
			Rational Aftadd;
			if (x.denom == 0 || y.denom == 0)exit(OVERFLOW);
			Aftadd.denom = x.denom * y.denom;
			Aftadd.mole = x.mole * y.denom + y.mole * x.denom;
			return Aftadd;
		}
		Rational sub(const Rational x, const Rational y) {
			Rational Aftsub;
			if (x.denom == 0 || y.denom == 0)exit(OVERFLOW);
			Aftsub.denom = x.denom * y.denom;
			Aftsub.mole = x.mole * y.denom - y.mole * x.denom;
			return Aftsub;
		}
		Rational mul(const Rational x, const Rational y) {
			Rational Aftmul;
			if (x.denom == 0 || y.denom == 0)exit(OVERFLOW);
			Aftmul.denom = x.denom * y.mole;
			Aftmul.mole = x.mole * y.denom;
			return Aftmul;
		}
		Rational div(const Rational x, const Rational y) {
			Rational Aftdiv;
			if (x.denom == 0 || y.denom == 0)exit(OVERFLOW);
			Aftdiv.denom = x.denom * y.denom;
			Aftdiv.mole = x.mole * y.mole;
			return Aftdiv;
		}
		Rational add(const Rational x, const int in) {
			Rational Aftadd;
			Rational  y;
			if (x.denom == 0)exit(OVERFLOW);
			y.denom = 1; y.mole = in;
			Aftadd.denom = x.denom * y.denom;
			Aftadd.mole = x.mole * y.denom + y.mole * x.denom;
			return Aftadd;
		}
		Rational sub(const Rational x, const int in) {
			Rational Aftsub;
			Rational  y;
			if (x.denom == 0)exit(OVERFLOW);
			y.denom = 1; y.mole = in;
			Aftsub.denom = x.denom * y.denom;
			Aftsub.mole = x.mole * y.denom - y.mole * x.denom;
			return Aftsub;
		}
		Rational mul(const Rational x, const int in) {
			Rational Aftmul;
			Rational  y;
			if (x.denom == 0)exit(OVERFLOW);
			y.denom = 1; y.mole = in;
			Aftmul.denom = x.denom * y.mole;
			Aftmul.mole = x.mole * y.denom;
			return Aftmul;
		}
		Rational div(const Rational x, const int in) {
			Rational Aftdiv;
			Rational  y;
			if (x.denom == 0)exit(OVERFLOW);
			y.denom = 1; y.mole = in;
			Aftdiv.denom = x.denom * y.denom;
			Aftdiv.mole = x.mole * y.mole;
			return Aftdiv;
		}
	};
	class lessThan {
	public:
		bool CompSize(const Rational x, const Rational y) {
			int x_mole = x.mole * y.denom;
			int y_mole = y.mole * x.denom;
			if (x_mole >= y_mole)return true;
			return false;
		}
	};
}
#endif // !_RATIONAL.H_

輸出結果