មេរៀន ទី៨ Inheritance ក្នុង C++

 គោលបំណងនៃមេរៀន

ក្រោយពីសិក្សាមេរៀននេះចប់ សិស្សនឹងអាច៖

1. យល់ពីគោលគំនិតនៃ Inheritance និងទំនាក់ទំនងរវាង Base Class និង Derived Class។
2. កំណត់ និងអនុវត្តប្រភេទផ្សេងៗនៃ Inheritance៖ Single, Multiple, និង Multilevel។
3. ប្រើ Virtual Base Classes ដើម្បីដោះស្រាយបញ្ហាភាពមិនច្បាស់លាស់ក្នុង Multiple Inheritance។
4. បង្កើត និងប្រើ Abstract Classes ជាមួយ Pure Virtual Functions។
5. សរសេរកម្មវិធី C++ ដែលបង្ហាញពី Inheritance ជាមួយ Syntax និងរចនាសម្ព័ន្ធត្រឹមត្រូវ។

១. ការយល់ដឹងអំពី Inheritance៖ Base Class និង Derived Class

គោលគំនិត

Inheritance គឺជាលក្ខណៈសំខាន់នៃ Object-Oriented Programming (OOP) ក្នុង C++ ដែលអនុញ្ញាតឱ្យ Class មួយ (ហៅថា Derived Class) ទទួលយកលក្ខណៈសម្បត្តិ និងឥរិយាបថ (Data Members និង Member Functions) ពី Class ផ្សេងទៀត (ហៅថា Base Class)។ នេះជួយលើកកម្ពស់ការប្រើប្រាស់កូដឡើងវិញ និងបង្កើតទំនាក់ទំនងជាឋានានុក្រមរវាង Classes។

• Base Class: Class មេ ដែលលក្ខណៈសម្បត្តិត្រូវបានទទួល។
• Derived Class: Class កូន ដែលទទួលពី Base Class។

Syntax

class BaseClass {
public:
    // Data members and member functions
};

class DerivedClass : access_specifier BaseClass {
public:
    // Additional data members and member functions
};

• access_specifier: អាចជា public, protected, ឬ private។ វាកំណត់របៀបដែល Members របស់ Base Class អាចចូលប្រើបានក្នុង Derived Class។
• ជម្រើសទូទៅ៖ public Inheritance ដែលរក្សា Public Members របស់ Base Class ជា Public ក្នុង Derived Class។

ឧទាហរណ៍៖ Single Inheritance

#include <iostream>
using namespace std;

class Animal { // Base class
public:
    void eat() {
        cout << "This animal eats food." << endl;
    }
};

class Dog : public Animal { // Derived class
public:
    void bark() {
        cout << "The dog barks!" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat();  // Inherited from Animal
    myDog.bark(); // Defined in Dog
    return 0;
}

ការពន្យល់

• Base Class (Animal): កំណត់ឥរិយាបថទូទៅ (eat) សម្រាប់សត្វទាំងអស់។
• Derived Class (Dog): ទទួលពី Animal ដោយប្រើ public Inheritance ដូច្នេះវាអាចចូលប្រើ eat។ វាក៏បន្ថែមឥរិយាបថជាក់លាក់ (bark)។
• លទ្ធផល:

  This animal eats food.
  The dog barks!
  

• វត្ថុ Dog អាចហៅទាំង Method eat ដែលទទួលមក និង Method bark របស់ខ្លួន ដែលបង្ហាញពីការប្រើប្រាស់កូដឡើងវិញ។

២. ប្រភេទនៃ Inheritance

២.១ Single Inheritance

Derived Class ទទួលពី Base Class តែមួយ (ដូចឧទាហរណ៍ខាងលើ)។

២.២ Multiple Inheritance

Derived Class ទទួលពី Base Classes ច្រើនជាងមួយ។

Syntax

class DerivedClass : access_specifier BaseClass1, access_specifier BaseClass2 {
    // Class body
};

ឧទាហរណ៍៖ Multiple Inheritance

#include <iostream>
using namespace std;

class Engine {
public:
    void start() {
        cout << "Engine starts." << endl;
    }
};

class Wheels {
public:
    void roll() {
        cout << "Wheels are rolling." << endl;
    }
};

class Car : public Engine, public Wheels {
public:
    void drive() {
        cout << "Car is driving!" << endl;
    }
};

int main() {
    Car myCar;
    myCar.start(); // From Engine
    myCar.roll();  // From Wheels
    myCar.drive(); // From Car
    return 0;
}

ការពន្យល់

• Base Classes: Engine និង Wheels ផ្តល់នូវមុខងារជាក់លាក់។
• Derived Class (Car): ទទួលពីទាំង Engine និង Wheels ដោយរួមបញ្ចូលឥរិយាបថរបស់ពួកគេ។
• លទ្ធផល:

  Engine starts.
  Wheels are rolling.
  Car is driving!
  

• Class Car ប្រើ Methods ពី Base Classes ទាំងពីរ និងបន្ថែម Method drive របស់ខ្លួន។

២.៣ Multilevel Inheritance

Derived Class ក្លាយជា Base Class សម្រាប់ Class ផ្សេងទៀត បង្កើតជាខ្សែសង្វាក់នៃ Inheritance។

ឧទាហរណ៍៖ Multilevel Inheritance

#include <iostream>
using namespace std;

class Animal {
public:
    void eat() {
        cout << "Animal eats food." << endl;
    }
};

class Mammal : public Animal {
public:
    void walk() {
        cout << "Mammal walks." << endl;
    }
};

class Dog : public Mammal {
public:
    void bark() {
        cout << "Dog barks!" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat();  // From Animal
    myDog.walk(); // From Mammal
    myDog.bark(); // From Dog
    return 0;
}

ការពន្យល់

• ខ្សែសង្វាក់ Inheritance: Animal → Mammal → Dog។
• ការចូលប្រើ: Class Dog ទទួល eat ពី Animal (តាមរយៈ Mammal) និង walk ពី Mammal។
• លទ្ធផល:

  Animal eats food.
  Mammal walks.
  Dog barks!
  

• នេះបង្ហាញពីរចនាសម្ព័ន្ធឋានានុក្រម ដែលកម្រិតនីមួយៗបន្ថែមឥរិយាបថជាក់លាក់បន្ថែម។

៣. Virtual Base Classes

គោលគំនិត

ក្នុង Multiple Inheritance ប្រសិនបើ Base Classes ពីរទទួលពី Base Class ដូចគ្នា Derived Class អាចនឹងទទួលបានច្បាប់ចម្លងច្រើននៃ Base Class ដែលនាំឱ្យមានភាពមិនច្បាស់លាស់។ Virtual Base Class ធានាថាមានតែច្បាប់ចម្លងតែមួយនៃ Base Class ត្រូវបានទទួល។

Syntax

class Base {
    // Class body
};

class Derived1 : virtual public Base {
    // Class body
};

class Derived2 : virtual public Base {
    // Class body
};

class FinalDerived : public Derived1, public Derived2 {
    // Class body
};

ឧទាហរណ៍៖ Virtual Base Class

#include <iostream>
using namespace std;

class Vehicle {
public:
    void move() {
        cout << "Vehicle moves." << endl;
    }
};

class Car : virtual public Vehicle {
public:
    void drive() {
        cout << "Car drives." << endl;
    }
};

class Boat : virtual public Vehicle {
public:
    void sail() {
        cout << "Boat sails." << endl;
    }
};

class Amphibious : public Car, public Boat {
public:
    void operate() {
        cout << "Amphibious vehicle operates on land and water." << endl;
    }
};

int main() {
    Amphibious myVehicle;
    myVehicle.move();   // No ambiguity due to virtual inheritance
    myVehicle.drive();  // From Car
    myVehicle.sail();   // From Boat
    myVehicle.operate(); // From Amphibious
    return 0;
}

ការពន្យល់

• បញ្ហាដោយគ្មាន Virtual: Amphibious នឹងទទួលច្បាប់ចម្លងពីរនៃ Vehicle (មួយតាម Car និងមួយតាម Boat) ដែលបណ្តាលឱ្យមានភាពមិនច្បាស់លាស់នៅពេលហៅ move។
• ដំណោះស្រាយ: ការប្រើ virtual Inheritance ធានាថាមានតែច្បាប់ចម្លងមួយនៃ Vehicle ត្រូវបានចែករំលែក។
• លទ្ធផល:

  Vehicle moves.
  Car drives.
  Boat sails.
  Amphibious vehicle operates on land and water.
  

• Virtual Inheritance ដោះស្រាយបញ្ហា "Diamond Problem" ក្នុង Multiple Inheritance។

៤. Abstract Classes

គោលគំនិត

Abstract Class គឺជា Class ដែលមិនអាចបង្កើត Instance បាន ហើយត្រូវបានរចនាឡើងដើម្បីឱ្យ Derived Classes ទទួល។ វាមានយ៉ាងហោចណាស់ Pure Virtual Function មួយ ដែលតម្រូវឱ្យ Derived Class បដិសេធ (Override)។

Syntax

class AbstractClass {
public:
    virtual void pureVirtualFunction() = 0; // Pure virtual function
    // Other members
};

class DerivedClass : public AbstractClass {
public:
    void pureVirtualFunction() override {
        // Implementation
    }
};

ឧទាហរណ៍៖ Abstract Class

#include <iostream>
using namespace std;

class Shape { // Abstract class
public:
    virtual void draw() = 0; // Pure virtual function
    void common() {
        cout << "This is a shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a rectangle." << endl;
    }
};

int main() {
    Circle circle;
    Rectangle rect;
    circle.common(); // From Shape
    circle.draw();   // From Circle
    rect.common();   // From Shape
    rect.draw();     // From Rectangle
    return 0;
}

ការពន្យល់

• Abstract Class (Shape): មាន Pure Virtual Function draw (បង្ហាញដោយ = 0) ដែលធ្វើឱ្យវាជា Abstract។ វាមិនអាចបង្កើត Instance បានទេ។
• Derived Classes (Circle, Rectangle): ត្រូវតែ Override draw ដើម្បីផ្តល់នូវការអនុវត្តជាក់លាក់។
• Common Function: common គឺជា Function ធម្មតាក្នុង Shape ដែលត្រូវបានទទួលដោយ Derived Classes ទាំងពីរ។
• លទ្ធផល:

  This is a shape.
  Drawing a circle.
  This is a shape.
  Drawing a rectangle.
  

• Abstract Classes អនុវត្តកិច្ចសន្យាសម្រាប់ Derived Classes ដោយធានាថាពួកគេអនុវត្តឥរិយាបថជាក់លាក់។

សង្ខេប

• Inheritance អនុញ្ញាតឱ្យប្រើកូដឡើងវិញ និងបង្កើតទំនាក់ទំនងឋានានុក្រម។
• ប្រភេទនៃ Inheritance:
  • Single: Base Class តែមួយ។
  • Multiple: Base Classes ច្រើន។
  • Multilevel: ខ្សែសង្វាក់នៃ Inheritance។
• Virtual Base Classes: ការពារការទទួលច្បាប់ចម្លងស្ទួនក្នុង Multiple Inheritance។
• Abstract Classes: កំណត់ Interfaces ជាមួយ Pure Virtual Functions សម្រាប់ Derived Classes ដើម្បីអនុវត្ត។