Trang chủLập trìnhLập trình C/C++Bài tập Ma trận trong lập trình hướng đối tượng OOP C/C++

Bài tập Ma trận trong lập trình hướng đối tượng OOP C/C++

Đây là một dạng bài tập cơ bản giúp cho việc luyện tập lập trình C/C++, cũng như nẵm rõ lập trình hướng đối tượng hơn.

Ma trận trong lập trình hướng đối tượng OOP C/C++

Trong bài viết này mình sẽ hướng dẫn các bạn giải bài toán Ma trận trong C/C++ với OOP. Một số ý trong bài này sẽ bao gồm tạo class Ma Trận, định nghĩa các thuộc tính và phương thức ban đầu cho lớp Ma trận, viết code xử lý nhập xuất ma trận, kiểm tra ma trận, cộng 2 ma trận và nhân 2 ma trận.

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

Một ma trận trên C/C++ sẽ được biểu diễn bằng một mảng 2 chiều gồm n dòng và m cột. Vậy chúng ta sẽ định nghĩa lớp ma trận như sau:

//Khái báo lớp Ma trận
class Matrix{
//Thuộc tính ta sẽ để phạm vi truy caapjlaf private để che đậy thông tin
    private:
        int n; //Ma trận gồm n dòng
        int m; //m cột
        int A[100][100]; //Khai báo mảng A để biểu diễn ma trận gồm tối đa 100 dòng và 100 cột
};

Sau khi khai báo lớp Ma trận với các thuộc tính cần thiết 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 Matrix{
    private:
        int n;
        int m;
        int A[100][100];

//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ố
    	Matrix(){};
    	Matrix(int n, int m, int A[][100]){
    		this->n = n;
    		this->m = m;
    		for(int i = 0;i<n;i++){
    			for(int j = 0; j<n; j++){
    				this->A[i][j] = A[i][j];
				}
			}
		}
		
    //Phương thức kiểm tra ma trận hiện tại có bằng ma trận truyền vào
       bool sameSize(Matrix b){
		}
		

      //Phương thức này kiểm tra xem số cột ma trận này có bằng số hàng ma trận truyền vào
		bool checkCanMultiply(Matrix b){
		}

		//Phương thức nhập ma tran
		void nhap(){
		}
		
      //Phương thức xuất ma tran
		void xuat(){
		}
		

     //2 phương thức cộng và nhân ma tran sẽ có kiểu trả về là 1 Ma trận
		Matrix cong(Matrix b){
			
		}
		
		Matrix nhan(Matrix b){
			
		}
		

//Các phương thức get và set => Để lấy và thay đổi giá trị của thuộc tính
			void setN(int n){
			this->n = n;
		}
		void setM(int m){
			this->m = m;
		}
		void setElementMattrix(int value, int i, int j){
			this->A[i][j] = value;
		}
		
		int getN(){
			return this->n;
		}
		int getM(){
			return this->m;
		}
		int getElementMattrix(int i, int j){
			return this->A[i][j];
		}
};

Về cơ bản cấu trúc lớp Mattrix 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 Ma trận

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 <bits/stdc++.h>
using namespace std;

class Matrix{
    private:
        int n;
        int m;
        int A[100][100];
    public:
    	Matrix(){};
    	Matrix(int n, int m, int A[][100]){
    		this->n = n;
    		this->m = m;
    		for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				this->A[i][j] = A[i][j];
				}
			}
		}
		
		
		void nhap(){
			cout<<"Nhap n (So hang): "; cin>>n;
			cout<<"Nhap m (So cot): "; cin>>m;
			cout<<"\n\nNhap ma tran\n";
			for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				cout<<"A["<<i<<"]["<<j<<"] = ";
    				cin>>this->A[i][j];
				}
			}
		}
		
		void xuat(){
			for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				cout<<this->A[i][j]<<"  ";
				}
				cout<<"\n";
			}
		}
};

int main(){
	Matrix A;
	cout<<"\n\n--------------NHAP MA TRAN-----------\n";
	A.nhap();
	
	cout<<"\n\n--------------XUAT MA TRAN-----------\n";
	A.xuat();
}

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

Xây dựng phương thức cộng 2 ma trận

Điều kiện để cộng 2 ma trận là 2 ma trận phải có cùng kích thước, tức là số hàng và số cột của hai ma trận phải bằng nhau. Cộng 2 ma trận này ta chỉ việc cộng các phần tử có cùng vị trí với nhau thành 1 ma trận.

Ta sẽ viết phương thức cộng 2 ma trận như sau

//Hàm cộng 2 ma trận	
          Matrix cong(Matrix b){
			Matrix c; //Khai báo thêm ma trận c để tính tổng

			for(int i = 0;i<this->n;i++){
       		 	for(int j = 0;j<this->m;j++){
           			 c.A[i][j] = this->A[i][j] + b.A[i][j]; //kết quả thứ i, j chính bằng tổng phần tử vị trí thứ i, j của 2 ma trận
		        }
		    }
		    return c; //Trả về kq c là tổng 2 ma trận cho hàm
		}

Xây dựng phương thức nhân 2 ma trận

Phép nhân hai ma trận chỉ thực hiện được khi số lượng cột trong ma trận thứ nhất phải bằng số lượng hàng trong ma trận thứ hai. Ma trận kết quả, được gọi là tích ma trận, có số lượng hàng của ma trận đầu tiên và số cột của ma trận thứ hai.

Nếu ma trận A có kích thước (m×n) và ma trận B có kích thước (n×p), thì ma trận tích C=A×B có kích thước (m×p), phần tử đứng ở hàng thứ i, cột thứ j xác định bởi công thức:

Tính tích 2 ma trận(Nhân 2 ma trận trận) trong lập trình C/C++

Vậy đã có công thức, ta viết phương thức nhân 2 ma trận như sau:

	Matrix nhan(Matrix b){
			Matrix c;	
			for(int i=0;i<this->n;i++) 
		        for(int j=0;j<b.m;j++) {
		         int tt=0;
		           for(int k=0;k<this->m;k++)
		               {
		                  tt = tt + (this->A[i][k] * b.A[k][j]); //Công th?c tính C[i][j]
		                }
		            c.A[i][j] = tt;
		    }
		}

Xây dựng 2 phương thức kiểm tra ma trận

Phương thức kiểm tra 2 ma trận có kích thước bằng nhau

	 //Hàm kiểm tra ma trận hiện tại và ma trận truyền vào có kích thươc bằng nhau kh
      bool sameSize(Matrix b){
           //Nếu n và m của ma trận hiện tại và ma trận truyền vào đều bằng nhau thì 2 ma trận cùng kích thước
			if(this->n == b.getN() && this->m == b.getM()) return true;
			return false;
		}

Phương thức kiểm tra số cột ma trận hiện tại có bằng số hàng ma trận truyền vào

    //Phương thức kiểm tra số cột ma trận hiện tại có bằng số hàng ma trận truyền vào
     bool checkCanMultiply(Matrix b){
      //Lệnh if viết gon, tương đương nếu m hiện tại bằng n ma trận truyền vào trả về true và kg bằng thì trả về false
			return this->m == b.getN() ? true:false;
		}

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

Qua các ý trên ta đã xây dựng hoàn thành tất cả phương thức cho lớp Ma trận, vậy ta ghép lại được chương trình chính như bên dưới.

#include <bits/stdc++.h>
using namespace std;

class Matrix{
    private:
        int n;
        int m;
        int A[100][100];
    public:
    	Matrix(){};
    	Matrix(int n, int m, int A[][100]){
    		this->n = n;
    		this->m = m;
    		for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				this->A[i][j] = A[i][j];
				}
			}
		}
		
		
		void nhap(){
			cout<<"Nhap n (So hang): "; cin>>n;
			cout<<"Nhap m (So cot): "; cin>>m;
			cout<<"\n\nNhap ma tran\n";
			for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				cout<<"A["<<i<<"]["<<j<<"] = ";
    				cin>>this->A[i][j];
				}
			}
		}
		
		void xuat(){
			for(int i = 0;i<n;i++){
    			for(int j = 0; j<m; j++){
    				cout<<this->A[i][j]<<"  ";
				}
				cout<<"\n";
			}
		}
		
		Matrix cong(Matrix b){
			Matrix c;
			for(int i = 0;i<this->n;i++){
       		 	for(int j = 0;j<this->m;j++){
           			 c.A[i][j] = this->A[i][j] + b.A[i][j];
		        }
		    }
		    return c;
		}
		
		bool sameSize(Matrix b){
			if(this->n == b.getN() && this->m == b.getM()) return true;
			return false;
		}
		
		bool checkCanMultiply(Matrix b){
			return this->m == b.getN() ? true:false;
		}
		Matrix nhan(Matrix b){
			Matrix c;	
			for(int i=0;i<this->n;i++) 
		        for(int j=0;j<b.m;j++) {
		         int tt=0;
		           for(int k=0;k<this->m;k++)
		               {
		                  tt = tt + (this->A[i][k] * b.A[k][j]); //Công th?c tính C[i][j]
		                }
		            c.A[i][j] = tt;
		    }
		}
		
		void setN(int n){
			this->n = n;
		}
		void setM(int m){
			this->m = m;
		}
		void setElementMattrix(int value, int i, int j){
			this->A[i][j] = value;
		}
		
		int getN(){
			return this->n;
		}
		int getM(){
			return this->m;
		}
		int getElementMattrix(int i, int j){
			return this->A[i][j];
		}
};

int main(){
	Matrix A;
	Matrix B;
	cout<<"\n\n--------------NHAP MA TRAN A-----------\n";
	A.nhap();
	cout<<"\n\n--------------NHAP MA TRAN B-----------\n";
	B.nhap();
	
	cout<<"\n\n--------------XUAT MA TRAN A-----------\n";
	A.xuat();
	cout<<"\n--------------XUAT MA TRAN B-----------\n";
	B.xuat();
	
	cout<<"\n\n--------------CONG 2 MA TRAN-----------\n";
	Matrix tong;
	if(A.sameSize(B) ==  true){
		tong = A.cong(B);
		tong.xuat();
	}else{
		cout<<"\n=>Khong the cong 2 ma tran khong cung kich thuoc";
	}
	
	
	cout<<"\n\n--------------TICH 2 MA TRAN-----------\n";
	Matrix tich;
	if(A.sameSize(B) ==  true){
		tich = A.nhan(B);
		tich.xuat();
	}else	{
		cout<<"\n=>Khong the cong 2 ma tran khong cung kich thuoc";
	}
}

Kết quả chạy chương trình.

Bài tập Ma trận trong lập trình hướng đối tượng OOP C/C++

Cảm ơn bạn đã đọc hết bài viết! CHúc HọC TốT!

[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