Trang chủLập trìnhLập trình C/C++Bài tập Phân số lập trình OOP trong C/C++ - Lập trình...

Bài tập Phân số lập trình OOP trong C/C++ – Lập trình hướng đối tượng

Phân số là một dạng bài tập cơ bản giúp cho việc luyện tập code lập trình C/C++.

Bài tập Phân số lập trình OOP trong C/C++

Trong phạm vi bài viết hôm nay mình sẽ hướng dẫn cách bạn giải quyết được bài toán phân số với lập trình OOP trong C/C++. Chúng ta sẽ lần lượt giải quyết các yêu cầu đối với bài toán phân số tạo lớp phân số, nhập xuất 1 phân số, rút gọn phân số, quy đồng 2 phân số, cộng trừ nhân chia 2 phân số.

Xây dựng lớp phân số với các thuộc tính và phương thức ban đầu

Một phân số thì bao gồm có tử số và mẫu số, như vậy trong class Phân Số chúng ta sẽ khai báo 2 thuộc tính là tử số và mẫu số. Vậy ta xây dựng lớp PhanSo bước đầu như sau.

//Khái báo lớp phân số
class PhanSo{
//Thuộc tính ta sẽ để phạm vi truy caapjlaf private để che đậy thông tin
	private:
		int tu;
		int mau;
};

Lớp PhanSo của chúng ta mới có thuộc tính mà chưa có các phương thức, chúng ta sẽ cần xây dựng các phương thức để thực hiện các nhiệm vụ tương ứng như đã nêu bên trên cho lớp Phân số.

class PhanSo{
	private:
		int tu;
		int mau;

//Phương thức chúng ta sẽ để chế độ public
	public:
       //2 phương thức khởi tạo (constructor) có tham số và không có thăm số
		PhanSo(){}
		PhanSo(int tu, int mau){
			this->tu = tu;
			this->mau = mau;
		}
		//Phương thức nhập phân số
		void nhap(){
		}
       //Phương thức xuất phân số
		void xuat(){
		}
    //Ham check phân số hợp lệ
      bool check(){
			if(this->tu == 0 || this->mau == 0)
			   return false;
			return true;
		}

       //Các phương thức rút gọn, quy đồng, cộng trừ nhân chia phân số
		void rutGon(){
			//Khoi lenh
		}
		void  quyDong(PhanSo &b){
			//Khoi lenh
		}
//Các phương thức cộng trừ nhân chia phân số sẽ có kiểu trả về là 1 PhanSo
		PhanSo congPhanSo(PhanSo b){
			//Khoi lenh
		}
		PhanSo truPhanSo(PhanSo b){
			//Khoi lenh
		}
		PhanSo nhanPhanSo(PhanSo b){
			//Khoi lenh
		}
		PhanSo chiaPhanSo(PhanSo b){
			//Khoi lenh
		}
		
      //Các phương thức get và set
		void setTu(int tu){
			this->tu = tu;
		}
			void setMau(int mau){
			this->tu = mau;
		}
		int getTu(){
			return this->tu;
		}
		int getMau(){
			return this->mau;
		}
		
};

Về cơ bản cấu trúc lớp PhanSo sẽ như vậy, bây giờ chúng ta sẽ cùng đi viết code cho từng phương thức.

Xây dựng phương thức nhập xuất cho phân số

Nếu bạn đã học tới OOP thì phần nhập xuất cơ bản bạn đã nắm rõ nên mình sẽ không giải thích gì nhiều, mà mình sẽ code luôn như sau:

#include <iostream>
using namespace std;

class PhanSo{
	private:
		int tu;
		int mau;
	public:
	
		PhanSo(){}
		PhanSo(int tu, int mau){
			this->tu = tu;
			this->mau = mau;
		}
		
	void nhap(){
			cout<<"Nhap tu so: ";
			cin>>this->tu;
			
			cout<<"Nhap mau so: ";
			cin>>this->mau;	
		}
		void xuat(){
			cout<<this->tu<<"/"<<this->mau;
		}
};

int main()
{
	PhanSo A; //Khai báo phân số A
	PhanSo B(4, 5); //Khai báo phân số B và gọi phương thức khởi tạo để khởi tọ giá trị ban đầu
	
    printf("Nhap phan so A\n");
	A.nhap(); //Gọi hàm để nhập phân số A

/*
	Phân số A thì mình cho nhập từ bàn phím, Phân số B thì mình lại sử dụng
phương thức khởi tạo nhằm mục đích để bạn hiểu rõ hơn về cách hoạt động của
phương thức khởi tạo (constructor)
	*/

	printf("Phan so A: ");
	A.xuat();  //Xuất phân số A
	printf("\nPhan so B: ");
	B.xuat(); //Xuất phân số B
   return 0;
}

Chạy chương trình được kết quả như bên dưới.

Xây dựng phương thức rút gọn phân số

Rút gọn phân số tức là ta đưa phân số về mức tối giản nhất(cả tử và mẫu không thể cùng chia hết cho một số nào > 1 nữa).

Như vậy để rút gọn phân số ta chỉ cần lấy cả tử và mẫu chia cho Ước chung lớn nhất của giá trị tuyệt đối của chúng.

Hàm để có thể tính được Ước số chung lớn nhất của 2 số là int __gcd(int a, int b) trong thư viện algorithm. Hoặc chúng ta có thể tự viết lại hàm __gcd như sau.

int __gcd(int a, int b){
    if(b==0) return a;
    return __gcd(b, a%b);
}

Mình có hản một bài viết riêng về tìm ƯCLN và BCNN, nếu bạn không hiểu hàm trên thì xem thêm nhé: Cách tìm UCLN và BCNN trong lập trình C/C++

Và tương tự hàm abs() là hàm lấy giá trị tuyệt đối cũng nằm trong thư viện algorithm. Và ta cũng có thể viết lại như sau:

int abs(int a){
    return a > 0 ? a : -a;
}

Như vậy bây giờ ta sẽ xây dựng code cho phương thức Rút gọn phân số.


	PhanSo rutGon(){
            int usc = 	int usc = __gcd(abs(this->tu), abs(this->mau));//Tìm ước số chung của giá trị tuyệt đối giữa tử và mẫu
			int usc = __gcd(abs(this->tu), abs(this->mau));
			this->tu = this->tu/usc;//Chia tử số cho ucln
			this->mau = this->mau/usc;//Chia mẫu số cho ước chung lớn nhất
		}

Xây dựng phương thức Quy đồng phân số

Quy đồng phân số chúng ta có thể hiểu đơn giản là biến đổi các phân số về mẫu số chung.

Mục đích của việc quy đồng phân số là để có thể cộng trừ phân số(Phân số chỉ có thể cộng hoặc trừ khi có cùng mẫu số chung).

Để quy đồng phân thì cũng rất đơn giản, tử số của phân số này sẽ bằng chính tử của phân số đó nhân với mẫu số của phân số kia, mẫu số chung thì lấy mẫu của 2 phân số nhân với nhau.

Vậy ta sẽ viết code cho phương thức Quy đồng như sau:

//phươn thức quy đồng phân số
void quyDong(PhanSo &b){
	    this -> rutGon();//Rút gọn phân số hiên tại
		b.rutGon();//Rút gọn phân só b (phân số truyền vào)

		 //Tu số sẽ được tính bằng cánh lấy tử phân số này nhân mẫu phân số nọ
		this->tu =  this->tu * b.mau;
	    b.tu = b.tu * this->mau;

       //Mẫu số chung sẽ tính bằng cách nhân 2 mẫu số với nhau
	    this->mau = b.mau  = this->mau * b.mau;	

      //Vì b ta truyền vào thăm biến nên sau khi thoát khỏi hàm b cũng sẽ bị thay đổi
}	

Xây dựng phương thức cộng hai phân số

Điều kiện để cộng 2 phân số đó là 2 phân số phải được quy đồng.

Để cộng 2 phân số đã được quy đồng ta thực hiện cộng tử với tử, mẫu ta lấy mẫu của 1 trong 2 phân số (Vì phân số đã quy đồng nên mẫu bằng nhau).

Ta viết code cho phương thức cộng 2 phân số như sau:

//Phương thức coongj2 phân số	
PhanSo congPhanSo(PhanSo b){
			this->quyDong(b); //Quy đồng phân số hiện tại với phân số truyền vào trước khi công
			PhanSo c;  //Khaii bao thêm phân số c

//Thực hiện cộng phan số
			c.tu = this->tu + b.tu;
			c.mau = this->mau;

			c.rutGon(); //Thực hiện rút gọn kết quả
			return c; //trả về kết quả
		}

Xây dựng phương thức trừ hai phân số

Điều kiện để trừ 2 phân số đó là 2 phân số phải được quy đồng.

Để trừ 2 phân số đã được quy đồng ta thực hiện trừ tử với tử, mẫu ta lấy mẫu của 1 trong 2 phân số (Vì phân số đã quy đồng nên mẫu bằng nhau).

Ta viết code cho phương thức trừ 2 phân số như sau:

//Hàm trừ2 phan số		
PhanSo truPhanSo(PhanSo b){
			this->quyDong(b);//Quy đồng phân số hiện tại với phân số truyền vào trước khi trừ
			PhanSo c;

        //Thực hiện trừ 2 phan số
			c.tu = this->tu - b.tu;
			c.mau = this->mau;

			c.rutGon();//Thực hiện rút gọn kết quả
			return c; //trả về kết quả
		}

Xây dựng phương thức nhân hai phân số

Để thực hiện nhân 2 phân số ta thực hiện nhân tử với tử, mẫu với mẫu.

Ta viết code cho phương thức nhân 2 phân số như sau:

//Hàm nhân 2 phan số		
PhanSo nhanPhanSo(PhanSo b){
			PhanSo c;

        //Thực hiện chia 2 phan số
			c.tu = this->tu * b.tu;
			c.mau = this->mau * b.mau;
			c.rutGon();//Thực hiện rút gọn kết quả
			return c; //trả về kết quả
		}

Xây dựng phương thức chia hai phân số

Để thực hiện chia 2 phân số, tử của phân số sẽ lấy bằng cách nhân tử của phân số chia cho mẫu số số bị chia, và mẫu số được tính bằng cách nhân mẫu số của số chia nhân với mẫu số của số bị chia (nhân nghịch đảo).

Ta viết code cho phương thức nhân 2 phân số như sau:

//Hàm chia 2 phan số	
PhanSo chiaPhanSo(PhanSo b){
			PhanSo c;

        //Thực hiện nhân 2 phan số
			c.tu = this->tu * b.mau;
			c.mau = this->mau + b.tu;
			c.rutGon();//Thực hiện rút gọn kết quả
			return c; //trả về kết quả
		}

Chương trình mẫu hoàn chỉnh

Vậy từ các ý trên ta có thể hoàn thành chương trình Phân số như sau. Nếu có ý nào không hiểu thì xem lại bên trên nhé, mình có comment code khá đầy đủ đấy ạ.

#include <iostream>
#include <algorithm>

using namespace std;

class PhanSo{
	private:
		int tu;
		int mau;
	public:
	
		PhanSo(){}
		PhanSo(int tu, int mau){
			this->tu = tu;
			this->mau = mau;
		}
		
		void nhap(){
			cout<<"Nhap tu so: ";
			cin>>this->tu;
			
			cout<<"Nhap mau so: ";
			cin>>this->mau;	
		}
		void xuat(){
			cout<<this->tu<<"/"<<this->mau;
		}
		bool check(){
			if(this->tu == 0 || this->mau == 0)
			   return false;
			return true;
		}
		void rutGon(){
			int usc = __gcd(abs(this->tu), abs(this->mau));
			this->tu = this->tu/usc;
			this->mau = this->mau/usc;
		}
		void quyDong(PhanSo &b){
		    this -> rutGon();
		    b.rutGon();
		    
		    this->tu =  this->tu * b.mau;
		    b.tu = b.tu * this->mau;
		    
		    this->mau = b.mau  = this->mau * b.mau;
		}
		
		PhanSo congPhanSo(PhanSo b){
			this->quyDong(b);
			PhanSo c;
			c.tu = this->tu + b.tu;
			c.mau = this->mau;
			c.rutGon();
			return c;
		}
		
		PhanSo truPhanSo(PhanSo b){
			this->quyDong(b);
			PhanSo c;
			c.tu = this->tu - b.tu;
			c.mau = this->mau;
			c.rutGon();
			return c;
		}
		PhanSo nhanPhanSo(PhanSo b){
			PhanSo c;
			c.tu = this->tu * b.tu;
			c.mau = this->mau * b.mau;
			c.rutGon();
			return c;
		}
		PhanSo chiaPhanSo(PhanSo b){
			PhanSo c;
			c.tu = this->tu * b.mau;
			c.mau = this->mau + b.tu;
			c.rutGon();
			return c;
		}
		
		void setTu(int tu){
			this->tu = tu;
		}
			void setMau(int mau){
			this->tu = mau;
		}
		int getTu(){
			return this->tu;
		}
		int getMau(){
			return this->mau;
		}
		
};

int main()
{
	PhanSo A;
	PhanSo B(90, 100);

    cout<<"Nhap phan so A\n";
	A.nhap();
	/*
	
	*/
	
	cout<<"-------------XUAT-------\n";
	cout<<"Phan so A: ";
	A.xuat();
	cout<<"\nPhan so B: ";
	B.xuat();
	
	if(A.check() == false){
		cout<<"\n=>Phan so A kh hop le";
		return 0;
	}
	if(B.check() == false){
		cout<<"\n=>Phan so A kh hop le";
		return 0;
	}
	
	cout<<"\n\n-------------RUT GON PHAN SO-------\n";
	printf("Phan so A: ");
	A.rutGon();
	A.xuat();
	printf("\nPhan so B: ");
	B.rutGon();
	B.xuat();
	
	cout<<"\n\n-------------QUY DONG PHAN SO-------\n";
	printf("Phan so A: ");
	A.quyDong(B);
	A.xuat();
	printf("\nPhan so B: ");
	B.xuat();
	
	
	cout<<"\n\n-------------CONG HAI PHAN SO-------\n";
	printf("Tong phan so: ");
	PhanSo tong = A.congPhanSo(B);
	tong.xuat();
	
	
	cout<<"\n\n-------------TRU HAI PHAN SO-------\n";
	printf("hieu phan so: ");
	PhanSo hieu = A.truPhanSo(B);
	hieu.xuat();
	
	cout<<"\n\n-------------NHAN HAI PHAN SO-------\n";
	printf("Tong phan so: ");
	PhanSo tich = A.nhanPhanSo(B);
	tich.xuat();
	
	cout<<"\n\n-------------CHIA HAI PHAN SO-------\n";
	printf("Tong phan so: ");
	PhanSo thuong = A.chiaPhanSo(B);
	thuong.xuat();
	
	return 0;
}

Và dưới đây là kết quả chạy thử chương trình.

Bài tập Phân số lập trình OOP trong C/C++ - Lập trình hướng đối tượng

[Xem tất cả bài viết chủ đề C/C++ tại đây]

0 0 Phiếu bình chọn
Xếp hạng bài viết
BÀI VIẾT LIÊN QUAN
Đăng ký nhận thông báo
Thông báo email khi
guest
0 Bình luận
Không thể gửi email
Phản hồi nội tuyến

NÊN ĐỌC THÊM

Bạn muốn tìm kiếm gì?


0
Giáo sư! có thể ném gạch bên dưới nhé!x
()
x