c++ pure virtual function, abstract class, multiple inheritance code

pure virtual function은 Base 클래스 함수 = 0 과 같이 선언한다.

pure virtual function이 하나라도 존재하면 그 클래스는 abstract class다.

abstract class는 하위 클래스가 pure virtual function을 override 해 주지 않으면 그 클래스는 선언이 불가능하다.

 

유지보수 측면에서 보면 Interface가 되는 기본 Base class에는 implementation이나 member variable 선언을 해 주지 않는다.

그리고 모든 메소드를 pure virtual로 만드는 것이 유지보수 측면에서 매우 유리하다.

 

코드 >>

#include <iostream>
#include <array>
 
// Pure Virtual Function = 0
// 만약 Pure virtual function이 하나라도 있으면 Abstract class이다
// Abstract Class 는 Object 생성이 불가능하다.
 
// Interface가 되는 기본 Base Class에는 implementation이나 member variable을
// 적어주지 않는다. 유지보수 측면 때문이다. 
// 그리고 모든 메소드를 pure virtual로 만드는 것이 유리하다.
 
 
class Animal
{
public:
    virtual void speak() = 0; // pure virtual
    virtual void walk() = 0;
    virtual ~Animal() = default;
};
 
 
class Cat : public Animal
{
public:
 
    void speak() override
    {
        std::cout << "meow~" << std::endl;
    }
private:
    int legCount = 4;
};
 
class Dolphin : public Animal
{
public:
    void walk() override
    {
        std::cout << "we swim" << std::endl;
    }
private:
    int finCount = 2;
};
 
class Lion : public Animal
{
public:
    void speak() override
    {
        std::cout << " I am a Lion!" << std::endl;
    }
    void walk() override
    {
        std::cout << " Lion is walking " << std::endl;
    }
private:
    double lionData;
};
 
class Jindo
{
public:
    Jindo() {
        std::cout << "Jindo constructor" << std::endl;
    }
    virtual ~Jindo() {
        std::cout << "Jindo destructor" << std::endl;
    }
    virtual void speak()
    {
        std::cout << "I am Jindo!" << std::endl;
    }
 
private:
    double jindoData;
};
 
// For Diamond inheritance
 
class Shiba
{
public:
    Shiba() {
        std::cout << "Shiba constructor" << std::endl;
    }
    virtual ~Shiba() {
        std::cout << "Shiba destructor" << std::endl;
    }
    virtual void speak()
    {
        std::cout << " I am Shiba " << std::endl;
    }
private:
    double shibaData;
};
 
class jabDog : public Jindo, public Shiba
{
public:
    jabDog()
    {
        std::cout << "jabDog constructor" << std::endl;
    }
    ~jabDog()
    {
        std::cout << "jabDog destructor" << std::endl;
    }
    void speak() override {
        std::cout << " I am JabDog ! " << std::endl;
    }
private:
    double jobdogData;
};
 
int main()
{
    // PolyMorphism
    //Animal* polyAnimal = new Lion(); // Lion 클래스만큼의 데이터 생성(*Vtable, Animal data, Lion data)
                                     // 그러나 liondata는 볼 수 없음(upcasting)
 
    //delete polyAnimal;
 
 
    // Multiple Inheritance
    //jabDog jabdog;
    //std::cout << "Size of jabdog : " << sizeof(jabdog) << std::endl; // 40bytes (*VT, shibadata, *VT, jindodata, jobdogdata)
    //jabdog.speak();
 
    std::cout << "Jindo Polymorphism" << std::endl;
    // Polymorphism
    Jindo* polyJindo = new jabDog(); // jabdog은 상위 클래스인 jindo 만큼(*VTable, jindodata)만 볼 수 있다.
    std::cout << "size of polyjindo : " << sizeof(*polyJindo) << std::endl;
    polyJindo->speak();
    delete polyJindo;
    return 0;
}