1. Hãy dành vài giây Đăng nhập hoặc Đăng ký tài khoản để truy cập và sử dụng TBit hiệu quả nhất.
    Ẩn thông báo
  2. Bạn hãy like trang Facebook của TBit để nhận được tin tức công nghệ nhanh nhất từ chúng tôi.
    Ẩn thông báo
Đăng kí tài khoản Cập nhật tin tức

[C/C++] - Bài 14: Lập trình hướng đối tượng trong C++ (OOP)

Thảo luận trong 'Lập trình C/C++' bắt đầu bởi Admin, 21/4/15.

0/5, 0 phiếu

    1. Admin Founder

      * TÓM TẮT LÝ THUYẾT

      1. Giới thiêu lập trình hướng đối tượng (OOP) với C++
      - C++ là ngôn ngữ "lai" giữa lập trình Cấu trúc và Lập trình hướng đối tượng.
      - Lập trình hướng đối tượng (OOP- Object-Oriented Programming) là một cách tư duy mới, tiếp cận hướng đối tượng để giải quyết vấn đề bằng máy tính. Thuật ngữ OOP ngày càng trở nên thông dụng trong lĩnh vực công nghệ thông tin.
      - Lập trình hướng đối tượng (OOP) là một phương pháp thiết kế và phát triển phần mềm dựa trên kiến trúc lớp và đối tượng.
      - Trong lập trình hướng đối tượng trong mỗi chương trình chúng ta có một số các đối tượng (object) có thể tương tác với nhau , thuộc các lớp (class) khác nhau, mỗi đối tượng tự quản lý lấy các dữ liệu của riêng chúng.

      2. Khai báo lớp (class), đối tượng (object)
      i) Đối tượng (object)
      Đối tượng là một thực thể phần mềm bao bọc các thuộc tính và các phương thức liên quan.
      ii) Lớp (class)
      Lớp (class) là một thiết kế (blueprint) hay một mẫu ban đầu (prototype) định nghĩa các thuộc tính và các phương thức chung cho tất cả các đối tượng của cùng một loại nào đó.
      Một đối tượng là một thể hiện cụ thể của một lớp.
      iii) Khai báo lớp và đối tượng
      a. Khai báo lớp
      + Lớp gồm 2 thành phần:
      - Thuộc tính (attribute)
      - Phương thức (method)
      + Khai báo:
      Mã (C++):
      1.   class  <Tên lớp>
      2.   {  
      3.   public:
      4.   (danh sách các thành viên [bao gồm cả thuộc tính và phương thức]  có đặc tính công cộng)  
      5.   private:
      6.   (danh sách các thành viên [bao gồm cả thuộc tính và phương thức] có đặc tính riêng tư)  
      7.   protected:
      8.   (danh sách các thành viên [bao gồm cả thuộc tính và phương thức] có đặc tính bảo tồn)           
      9.   };  // dấu chấm phẩy chấm dứt câu lệnh
      + Việc sử dụng lớp trong một chương trình C++ có hai phần chính là phần định nghĩa lớp và phần khai báo và truy cập các thành viên của một đối tượng có kiểu là một lớp cho trước.
      Ví dụ:
      Mã (C++):
      1. class SV{  
      2.    // thuoc tinh
      3.    public:
      4.      char hoTen[30];
      5.      int tuoi;
      6.      float diem;
      7.    // phuong thuc
      8.    public:
      9.      void NhapDiem();    
      10.      float TinhDiem();
      11.    };
      b. Khai báo đối tượng
      Ví dụ:
      // t là đối tượng của lớp SV
      SV t = SV();

      3. Phương thức khởi tạo (Constructor) và phương thức hủy (Destructor)
      i) Phương thức khởi tạo (Constructor)
      + Các phương thức thiết lập có nhiệm vụ thiết lập thông tin ban đầu cho một đối tượng thuộc về lớp ngay khi đối tượng được khai báo.
      + Đặc điểm của phương thức thiết lập:
      - Tên của phương thức thiết lập trùng với tên lớp.
      - Phương thức thiết lập không có giá trị trả về.
      - Một lớp có thể có nhiều phương thức thiết lập khác nhau.
      - Trong quá trình tồn tại của đối tượng, chỉ có một lần duy nhất mà phương thức thiết lập được gọi thực hiện mà thôi đó là khi đối tượng ra đời.
      - Phân loại phương thức thiết lập: Có thể chia phương thức thiết lập thành 3 loại
      - Phương thức thiết lập mặc định (default contructor): là phương thức thiết lập không nhận tham số đầu vào. Các thông tin ban đầu cho đối tượng của lớp bằng những giá trị mặc định (do lập trình viên quy định). Phương thức thiết lập mặc định không có đối số.
      - Phương thức thiết lập sao chép (copy contructor): là phương thức thiết lập nhận tham số đầu vào là 1 đối tượng thuộc cùng 1 lớp. Các thông tin ban đầu của đối tượng sẽ hoàn toàn giống thông tin của đối tượng tham số đầu vào.
      - Phương thức thiết lập có tham số: là phương thức thiết lập không thuộc 2 loại trên. Các thông tin ban đầu của đối tượng sẽ phụ thuộc vào giá trị các tham số của phương thức thiết lập.

      Ví dụ: xây dựng class CphaSo
      Mã (C++):
      1.   class CPhanSo
      2.   {
      3.   private:
      4.   int tu;
      5.   int mau;
      6.   public:
      7.   CPhanSo();
      8.   CPhanSo(const CPhanSo&);
      9.   CPhanSo(int);
      10.   CPhanSo(int,int);
      11.   };
      12.  
      13.   // Khởi tạo mặc định
      14.   CPhanSo::CPhanSo()
      15.   {
      16.   tu = 0;
      17.   mau = 1;
      18.   }
      19. //Khởi tạo sao chép
      20. CPhanSo::CPhanSo(const CPhanSo& x)
      21. {
      22.   tu = x.tu;
      23.   mau = x.mau;
      24. }
      25. //Khởi tạo 1 tham số
      26. CPhanSo::CPhanSo(int t)
      27.   {
      28.   tu = t;
      29.   mau = 1;
      30.   }
      31.  
      32. // Khởi tạo 2 tham số
      33. CPhanSo::CPhanSo(int t, int m)
      34. {
      35.   tu = t;
      36.   mau = m;
      37. }
      ii) Phương thức hủy (Destructor)
      + Phương thức hủy có nhiệm vụ thu hồi lại bộ nhớ được cấp phát cho đối tượng thuộc lớp ngay khi đối tượng hết phạm vi hoạt động.
      + Các đặc điểm của phương thức hủy:
      - Phương thức hủy có tên trùng với tên lớp (có thêm dấu ~ phía trước).
      - Phương thức hủy không có giá trị trả về và cũng không nhận tham số đầu vào.
      - Mỗi lớp chỉ có nhiều nhất một phương thức hủy. Nếu lập trình viên không xây dựng hàm hủy thì trình biên dịch sẽ tạo ra một phương thức hủy mặc định.
      - Phương thức hủy chỉ được tự động gọi thực hiên một lần duy nhất (khi đối tượng hết phạm vi hoạt động).
      - Phương thức hủy phải được xây dựng khi trong phương thức khởi tạo, ta có sử dụng các hàm cấp phát bộ nhớ thì ta bắt buộc phải xây dựng phương thức hủy để thu hồi các bộ nhớ này lại.

      Ví dụ:
      Mã (C++):
      1. class CString
      2. {
      3.   private:
      4.      char *_text;
      5.      int  size;
      6.   public:
      7.      CString(char *ch);//Phương thức khởi tạo
      8.      ~CString(); // Phương thức hủy
      9.   };
      10.  
      11. // Định nghĩa phương thức khởi tạo
      12. CString::CString( char *ch )
      13. {
      14.   size = strlen(ch) + 1;
      15.   //Cấp phát bộ nhớ cho biến _text
      16.   _text = new char[size];
      17.   if(_text)
      18.   strcpy( _text, ch);
      19. }
      20.  
      21. // Định nghĩa phương thức hủy
      22. CString::~CString()
      23. {
      24.   // Thu hồi bộ nhớ cấp phát cho biến _text
      25.   if (_text)
      26.   delete[] _text;
      27. }
      4. Kế thừa (Inheritance)
      - Kế thừa là một đặc trưng quan trọng trong lập trình hướng đối tượng (OOP). Sự kế thừa trong các ngôn ngữ lập trình như C++, Java, C#, VB.Net,.. cơ bản là giống nhau.
      - Trong lập trình C++, có thêm khái niệm đa kế thừa mà các ngôn ngữ khác đã bỏ chức năng này do sự nhập nhằng khi sử dụng.
      - Kế thừa là cách tạo lớp mới từ các lớp đã được định nghĩa từ trước.

      Ví dụ:
      Mã (C++):
      1. //  class B kế thừa class A.
      2.   class A{
      3.   ....
      4.   };
      5.  
      6.   class B:A{
      7.   ...
      8.   };

      * Lưu ý:
      - Một lớp cha có thể có nhiều lớp con (có phép kế thừa)
      - Đến lượt mình mỗi lớp con lại có thể có các con khác
      - Trong C++ cho phép đa kế thừa (một lớp con có thể nhận hơn 1 lớp cha)

      5. Phương thức ảo (virtual)
      - Phương thức ảo là phương thức được định nghĩa ở lớp cơ sở (lớp cha) mà các lớp dẫn xuất (lớp con) muốn sử dụng phải định nghĩa lại. Dùng

      từ khoá virtual để khai báo phương thức ảo:
      - Cú pháp:
      Mã (C++):
      1.   virtual <kiểu DL> <tên P.Thức>([tham số])
      2.   {
      3.   …
      4.   }
      - Phương thức khởi tạo không được là phương thức ảo nhưng phương thức hủy bỏ có thể là phương thức ảo. Dùng phương thức ảo chậm hơn

      phương thức thông thường vì khi thực hiện mới được xác định cụ thể.

      6. Phương thức trừu tượng, và lớp trừu tượng (abstract)
      - Phương thức trừu tượng (thuần ảo) là phương thức ảo nhưng không có lệnh (phương thức rỗng). Phương thức thuần ảo có dạng:
      - Cú pháp:
      abstract <kiểu DL> <tên ph.thức>([tham số]) = 0;
      - Lớp có phương thức ảo gọi là lớp trừu tượng (abstract class). Nếu một lớp thừa kế lớp trừu tượng mà không định nghĩa lại phương thức thuần ảo thì lớp thừa kế cũng là lớp trừu tượng.

      * Lưu ý:
      - không được tạo đối tượng thuộc lớp trừu tượng.
      - Thường chọn phương thức ở lớp cha, mà chưa thể xác định cách thực hiện, làm phương thức thuần ảo. Ở lớp con ta sẽ định nghĩa lại

      phương thức thuần ảo, để xác định cụ thể cách thức thực hiện.

      7. Lớp bạn, hàm bạn (Friend)
      Trong khi viết các chương trình trong C++, đôi khi chúng ta cần cấp quyền truy xuất cho một hàm tới các thành viên không là các thành viên chung của một lớp. Một truy xuất như thế được thực hiện bằng cách khai báo hàm như là bạn của lớp. Có hai lý do có thể cần đến truy xuất này là:
      - Có thể là cách định nghĩa hàm chính xác.
      - Có thể là cần thiết nếu như hàm cài đặt không hiệu quả.
      - Cách viết một hàm bạn: Để một hàm trở thành hàm bạn, có hai cách viết:

      Cách 1: Đặt từ khóa friend trước các hàm được khai báo trong lớp, sau đó xây dựng hàm bên ngoài như bình thường.
      Mã (C++):
      1.  class A
      2. {
      3. private:
      4.   //Cac thuoc tinh
      5. public:
      6.   friend void h1(...);  
      7.   friend int h2(...);  
      8.   ....
      9. };
      10. void h1(...)
      11. {
      12.   ...
      13. }
      14. int h2(...)
      15. {
      16.   ...
      17. }
      Cách 2: Dùng từ khóa friend để xây dựng hàm trong định nghĩa lớp.
      Mã (C++):
      1.  class A
      2. {
      3.   private:
      4.   //Cac thuoc tinh  
      5. public:
      6.   friend void h1(...)  
      7.   {
      8.   ...
      9.   }
      10.   friend int h2(...)
      11.   {
      12.   ...
      13.   }
      14.   ...
      15. };
      - Tính chất của hàm bạn:
      + Trong thân hàm bạn của một lớp có thể truy nhập tới các thuộc tính của các đối tượng thuộc lớp này. Đây là khác nhau duy nhất giữa hàm bạn và hàm thông thường.
      + Hàm bạn không phải là phương thức của một lớp, lời gọi của hàm bạn giống như lời gọi của hàm thông thường.

      Bài tập ví dụ xem bài #2 ở dưới.
       

      Các file đính kèm:

      Admin, 21/4/15
      #1
      Đang tải...
      Có thể bạn quan tâmX
    2. Admin

      Admin Founder Thành viên BQT

      Điểm:
      14.584ß
      ** VÍ DỤ
      ---------------------------------

      Ví dụ 1:
      + Yêu cầu:
      Xây dựng lớp cha (Nguoi), lớp con (HocSinh).

      + Code:
      Mã (C++):
      1. #include<conio.h>
      2. #include<stdio.h>
      3. #include<iostream>
      4. #include<string.h>
      5.  
      6. using namespace std;
      7.  
      8. // lop cha
      9. class Nguoi
      10. {
      11.   protected:
      12.    char hoTen[30];
      13.   int namSinh;
      14.   private:  
      15.   char soThich[50]; // so thich
      16.   public:  
      17.      // khoi tao lop Nguoi
      18.   Nguoi(){
      19.   strcpy(hoTen,"Nguyen Van A");
      20.   namSinh=1990;
      21.   strcpy(soThich,"Lap trinh");
      22.   }
      23.  
      24.   // In thông tin
      25. void InTT();
      26. };
      27.  
      28. // lop con
      29. class HocSinh : public Nguoi
      30. {
      31.   protected:
      32.   int maHS;
      33.   public:
      34.   void Nhap();
      35.   void InTT();
      36. };
      37.  
      38. // InTT cua cha (Nguoi)
      39. void Nguoi::InTT()
      40. {
      41.   cout << "\n Nam sinh : " << namSinh;
      42.   cout << "\n Ho ten : " << hoTen;
      43.   cout << "\n So thich : " << soThich;
      44. }
      45.  
      46. // InTT cua con (HocSinh)
      47. void HocSinh::InTT()
      48. {
      49.   cout << "\n Ma hoc sinh : " << maHS;
      50.   cout << "\n Nam sinh : " << namSinh;
      51.   cout << "\n Ho ten : " << hoTen;
      52. }
      53.  
      54.   //  Nhap thong tin
      55. void HocSinh::Nhap()
      56. {
      57.   cout << "\n Nam sinh : "; cin>> namSinh;
      58.   cout << "\n Ho ten : "; gets(hoTen);
      59.   cout << "\n Ma hoc sinh: "; cin>> maHS;
      60. }
      61.  
      62. // ham main
      63. int main(){
      64.   // khai bao doi tuong Nguoi
      65.   Nguoi a;  a.InTT();
      66.   // khai bao doi tuong HocSinh
      67.   HocSinh t;  t.Nhap();  t.InTT();
      68.   return 0;
      69. }
      Ví dụ 2:
      + Yêu cầu: Phương thức ảo

      + Code:
      Mã (C++):
      1. #include<conio.h>
      2. #include<stdio.h>
      3. #include<iostream>
      4. #include<string.h>
      5.  
      6. using namespace std;
      7.  
      8. class A
      9. {
      10. public:
      11. //phuong thuc ao
      12.    virtual void Chao()
      13.    {
      14.      cout<<"\nA chao cac ban";
      15.    }
      16. };
      17.  
      18. class B:public A
      19. {
      20. public:
      21.     void Chao()
      22.    {
      23.      cout<<"\nB chao cac ban";
      24.    }
      25. };
      26.  
      27. class C:public A
      28. {
      29. public:
      30.     void Chao()
      31.    {
      32.      cout<<"\nC chao cac ban";
      33.    }
      34. };
      35.  
      36.  
      37. // ham main
      38. int main()
      39. {
      40. A a;
      41. A *pa= new A;
      42. pa->Chao(); //goi chao cua A
      43. B b;
      44. pa=&b;
      45. pa->Chao(); //goi chao cua B
      46. C c;
      47. pa=&c;
      48. pa->Chao(); //goi chao cua C
      49. return 0;
      50. }
      /* Giải thích:
      - Phương thức Chao() có tính đa hình: cùng lời gọi pa->chao() nhưng lần 1 gọi chao cua A, lan 2 gọi chao cua B, lan 3 goi chao cua C.
      - Nếu trong lớp B, C không định nghĩa lại phương thức chào thì cả ba lần đều gọi chào của A.
      - Nếu phương thức chao() trong lớp A không khai báo virtual thì phương thức chao() sẽ không có tính đa hình, khi đó cả ba lần đều gọi chào của A.
      - Có thể gán địa chỉ của đt thuộc lớp con vào biến con trỏ, trỏ tới đt thuộc lớp cha nhưng không thể làm ngược lại (áp dụng nguyên tắc “con gán vào cha” đối với biến kiểu đối tượng hoặc biến kiểu con trỏ, trỏ tới đối tượng)

      */

      Ví dụ 3:
      + Yêu cầu:
      Nhập một danh sách gồm giảng viên và sinh viên, in ra danh sách những người được thưởng. Biết rằng điều kiện được thưởng là giảng viên có số bài báo >3, sinh vien có điểm thi tốt nghiệp >8.

      + Code:
      Mã (C++):
      1. [plain]
      2.  
      3. #include<conio.h>
      4. #include<stdio.h>
      5. #include<iostream>
      6. #include<string.h>
      7.  
      8. using namespace std;
      9.  
      10. class Nguoi
      11. {
      12.  
      13. char hoten[30];
      14.  
      15. public:
      16.  
      17. //phuong thuc ao
      18.  
      19. virtual void nhap()
      20. {
      21.   cout<<"\nHo ten:"; cin.getline(hoten,30);
      22. }
      23.  
      24. //phuong thuc thuc ao (truu tuong)
      25. virtual int thuong()=0;
      26.  
      27. //phuong thuc ao
      28. virtual void xuat()
      29. {
      30.   cout<<"\nHo ten:"<<hoten;
      31. }
      32. };
      33.  
      34. // class sinhvien
      35. class Sinhvien:public Nguoi
      36. {
      37. float dttn;
      38. public:
      39. //dinh nghia lai phuong thuc nhap
      40. void nhap()
      41. {
      42.   Nguoi::nhap();
      43.   cout<<"\nDiem thi tn:"; cin>>dttn;
      44. }
      45.  
      46. //dinh nghia lai phuong thuc thuong
      47. int thuong()
      48. {
      49.   return (dttn>8?1:0);
      50. }
      51.  
      52. void xuat()
      53. {
      54.   cout<<"\n-Sinh vien:";
      55.   Nguoi::xuat();
      56.   cout<<"\nDiem thi tn:"<<dttn;
      57. }
      58. };
      59. class Giangvien:public Nguoi
      60. {
      61.   int sobaibao;
      62. public:
      63. void nhap()
      64. {
      65.   Nguoi::nhap();
      66.   cout<<"\nSo bai bao:"; cin>>sobaibao;
      67. }
      68. int thuong()
      69. {
      70.   return (sobaibao>3?1:0);
      71. }
      72. void xuat()
      73. {
      74.   cout<<"\n-Giang vien:";
      75.   Nguoi::xuat();
      76.   cout<<"\nSo bai bao:"<<sobaibao;
      77. }
      78. };
      79.  
      80. // ham main
      81. int main()
      82. {
      83. Nguoi *ds[100]; int k=0, chon, i;
      84. while(1)
      85. {
      86.   cout<<"\n*Chon: Gv / Sv / Close (1,2,3):";
      87.   cin>>chon;  cin.get();
      88.   if (chon==3) break;
      89.   if (chon==1) ds[k]=new Giangvien();
      90.   if (chon==2) ds[k]=new Sinhvien();
      91.   ds[k]->nhap(); k++;
      92. }
      93. cout<<"\n*Danh sach nhung nguoi duoc thuong";
      94. for (i=0; i<k; i++)
      95.   if (ds[i]->thuong()) ds[i]->xuat();
      96. return 0;
      97. }
      98.  
      99. [/plain]


      Ví dụ 4: (hàm bạn, lớp bạn)
      + Yêu cầu: Viết hàm Area để tính diện tích hình chữ nhật, Area là hàm bạn của lớp Rectangle

      + Code:
      Mã (C++):
      1. #include<conio.h>
      2. #include<stdio.h>
      3. #include<iostream>
      4. #include<string.h>
      5.  
      6. using namespace std;
      7.  
      8. class Rectangle
      9. {  
      10. private:
      11. int w;
      12. int h;
      13.  
      14. public:
      15. Rectangle(int, int);
      16.  
      17. // khai bao ham ban Area
      18. friend int Area(Rectangle);
      19.  
      20. };
      21.  
      22. Rectangle::Rectangle(int w, int h){  
      23. this->w = w;
      24. this->h = h;
      25. }
      26.  
      27. // ham ban
      28. int Area(Rectangle rec){
      29. return (rec.w*rec.h);
      30. }
      31. // ham main
      32. int main()
      33. {
      34.   Rectangle rec(2, 5);
      35.   cout<<"Dien tich HCN:  "<<Area(rec);
      36.   return 0;
      37. }
       
      Admin, 21/4/15
      #2
Từ khóa:

Chia sẻ trang này

Đang tải...