[C++] 26. 상속

기존의 방식

1. 상속의 개념_ 상속이란 무엇인가?

#include <iostream>
#include <string>

using namespace std;

// 상속의 개념
// 아래 구조체 monster와 player의 형태는 다르지만 공통된 속성과 기능이 있다
// 이는 중복되는 소스가 생기므로 효율이 떨어진다
// 중복되는 소스를 상위개념으로 해서 하나의 구조체(Charactor)를 만들어 놓고
// monster와 player에게 상속하게 만드는 것
// 하나의 부모 클래스로부터 특성이 조금씩 다른 자식 클래스를 얼마든지 파생시킬 수 있다.
// 상속 관계의 아래쪽으로 내려올수록 더 많은 속성과 동작이 정의된다.
// 위쪽의 선조 클래스는 멤버가 많지 않아 일반적이고 포괄적인 사물을 표현하는데 비해 
// 아래로 내려올수록 후손 클래스의 멤버가 늘어 특수하고 구제적인 사물을 표현한다.

struct Charactor
{
    string name;
    int hp;
    int atk;

    void Attack()
    {
        cout << name << "공격" << endl;
    }
    void Hit()
    {
        cout << name << "맞음" << endl;
    }
    void Die()
    {
        cout << name << "죽음" << endl;
    }
};

//  상속받을자식 : 상속할부모
struct Monster : Charactor
{
    bool isChase;

    Monster(string _name, int _hp, int _atk, bool _isChase)
    {
        name = _name;
        hp = _hp;
        atk = _atk;
        isChase = _isChase;
    }
    void ChaseTarget()
    {
        cout << "몬스터가 쫒아감" << endl;
    }
};

struct Player : Charactor
{
    int def;

    Player(string _name, int _hp, int _atk, int _def)
    {
        name = _name;
        hp = _hp;
        atk = _atk;
        def = _def;
    }

    void Skill()
    {
        cout << "유저 스킬 사용" << endl;
    }
};

void main()
{
    Monster monsterA("드래곤", 100, 10, false);
    monsterA.Attack();
    monsterA.Hit();
    monsterA.Die();
    cout << endl;

    Player playerA("유저", 100, 5, 5);
    playerA.Attack();
    playerA.Hit();
    playerA.Die();
    playerA.Skill();
}

 

상속을 쓴 상태

출력 결과

2. 상속의 개념_ 자식은 기능과 속성 뿐 아니라 정체성까지 부모로부터 상속된다.

#include <iostream>
#include <string>

using namespace std;

//상속


struct Charactor
{
    string name;
    int hp;
    int atk;

    Charactor()
    {

    }

    Charactor(string _name, int _hp, int _atk)
    {
        name = _name;
        hp = _hp;
        atk = _atk;
    }

    void Attack()
    {
        cout << "캐릭터 공격" << endl;
    }
    void Hit()
    {
        cout << "캐릭터 맞음" << endl;
    }
    void Die()
    {
        cout << "캐릭터 죽음" << endl;
    }
};


//  상속받을자식 : 상속할부모
struct Monster : Charactor
{
    bool isChase;

    /*
    Monster(string _name, int _hp,int _atk, bool _isChase)
    {
       name = _name;
       hp = _hp;
       atk = _atk;
       isChase = _isChase;
    }
    */

    //위의 형태가 번거롭기때문에 부모의 생성자를 사용해서 초기화를 편하게 할 수 있음.
    Monster(string _name, int _hp, int _atk, bool _isChase) : Charactor(_name, _hp, _atk)
    {
        isChase = _isChase;
    }


    void ChaseTarget()
    {
        cout << "몬스터가 쫒아감" << endl;
    }
};

struct Player : Charactor
{
    int def;

    Player()
    {

    }

    Player(string _name, int _hp, int _atk, int _def) : Charactor(_name, _hp, _atk)
    {
        def = _def;
    }

    void Skill()
    {
        cout << "유저 스킬 사용" << endl;
    }
};

struct Dragon : Monster
{
    bool isFly;

    Dragon(string _name, int _hp, int _atk, bool _isChase, bool _isFly) : Monster(_name, _hp, _atk, _isChase)
    {
        isFly = _isFly;
    }
};

void main()
{
   // 상속의 중요한 개념
   // 자식은 기능과 속성뿐 아니라 정체성까지 부모로부터 상속된다.
   // 이 개념이 중요한 이유는 배열을 통해 적용이 되기 때문이다.

    Monster* monsterA = new Monster("몬스터", 100, 10, false);
    Player* playerA = new Player("유저A", 100, 5, 5);
    Dragon* dragonA = new Dragon("그린드래곤", 100, 10, false, false);

    Charactor* charactors[3];
    charactors[0] = monsterA;
    charactors[1] = playerA;
    charactors[2] = dragonA;

    playerA->name = "유저테스트";


    for (int i = 0; i < 3; i++)
    {
        cout << charactors[i]->name << endl;
    }

    // 자식은 부모에게 포함될수 있지만 부모는 자식에게 포함되지 않는다.
    // Player tempPlayer;
    //  tempPlayer = charactors[1];    이거 안됨~ 오류뜸!!
}

출력 결과

* 자식은 부모에게 포함될수 있지만 부모는 자식에게 포함되지 않아~~~~~

* 자식은 부모에게 포함될수 있지만 부모는 자식에게 포함되지 않아~~~~

* 자식은 부모에게 포함될수 있지만 부모는 자식에게 포함되지 않아~~~

* 자식은 부모에게 포함될수 있지만 부모는 자식에게 포함되지 않아~~

* 자식은 부모에게 포함될수 있지만 부모는자식에게 포함되지 않아~