[C++] 타입 변환 4: 포인터

    타입 변환 4: 포인터

 

인프런 Rookiss님의 'Part1: C++ 프로그래밍 입문' 강의를 기반으로 정리한 필기입니다. 
😎[C++과 언리얼로 만드는 MMORPG 게임 개발 시리즈] Part1: C++ 프로그래밍 입문 강의 들으러 가기!

 

 

---

 

공통 부분

 

#include <iostream>
using namespace std;

// 타입 변환 (포인터)

class Knight{
public:
    int _hp = 0;
};

class Item{
public:
    Item() { cout << "Item()" << endl; }

    Item(int itemType) : _itemType(itemType) { }

    Item(const Item& item) { cout << "Item(const Item&)" << endl; }

    ~Item() { cout << "~Item()" << endl; }

public:
    int _itemType = 0;
    int _itemDbld = 0;

    char _cummy[4096] = {}; // 이런 저런 정보들로 인해 비대해진 아이템 클래스를 나타내기 위해 표시
};

enum ItemType
{
    IT_WEAPON = 1,
    IT_ARMOR =2,
};

class Weapon : public Item
{
public:
    Weapon() : Item(IT_WEAPON)
    {
        _itemType = 1;
        cout << "Weapon()" << endl;
    }

    ~Weapon()
    {
        cout << "~Weapon()" << endl;
    }

public:
    int _damage = 0;
};

class Armor : public Item{
public:
    Armor() : Item(IT_ARMOR) { cout << "Armor()" << endl; }

    ~Armor() { cout << "~Armor()" << endl; }

public:
    int _defence = 0;
};

 

 

---

 

연관성이 없는 클래스 사이의 포인터 변환 테스트

 

int main()
{   
    // Stack [ 주소 ] -> Heap [ _hp(4) ]
    Knight* knight = new Knight();

    // 암시적으로는 NO
    // 명시적으로는 OK

    // Stack [ 주소 ]
    Item* item = (Item*)knight;
    item->_itemType = 2; // 4byte로 유효한 정보를 건드리기 때문에 정상적으로 변경된다. 
    item->_itemDbld = 1; // 데이터의 유효 범위를 벋어나서 문제가 된다.

    delete knight;
}

 

delete knight; 하지 않는 경우, 컴파일은 통과되지만  item->_itemDbld = 1;가 문제가 된 상태로 넘어갈 수 있다.

이 경우, 추후에 나비효과가 되어 돌아올 수 있다.

---

 

 

다운 캐스트: 부모 -> 자식 변환 (Base class -> Derived class)

 

부모 -> 자식 변환은 명시적으로 사용해야 통과된다.

int main()
{
    Item* item = new Item();

    // [ [ Item ]  ]
    // [  _damage  ]
    Weapon* weapon = (Weapon*)item;  // 위험한 상황, 잘못된 코드
    Weapon->_damage = 10;            // 잘못된 메모리를 건드림, 잘못된 코드

    delete item;
}

Object Slicing 을 조심해야 한다.

 

메모리의 크기가 큰 것에서 작은 것으로 변환하는 경우, 엉뚱한 메모리를 건드릴 수 있다. 

위의 경우, item은 weapon보다 메모리의 크기가 크다. (*Weapon)item과 같이 명시적 변화를 하면 엉뚱한 메모리를 건드릴 수 있다.

 

명시적으로 타입 변환할 때는 항상 항상 조심해야 한다!

---

 

 

자식 -> 부모 변환 테스트

 

int main()
{
    // [ [ Item ]  ]
    // [  _damage  ]
    Weapon* weapon = new Weapon();

    // 암시적으로도 된다!
    Item* item = weapon;    // Item* item = (item*) weapon;  // (item*) 부분이 생략되어있다

    delete weapon;
}

 

---

 

조심할 사항들

 

명시적으로 타입 변환할 때는 항상 항상 조심해야 한다!
암시적으로 될 때는 안전하다?

 -> 평생 명시적으로 타입 변환(캐스팅)은 안 하면 되는거 아닌가?

int main()
{
    Item* inventory[20] = {};

    srand((unsigned int)time(nullptr));

    for (int i = 0; i < 20; i++)
    {
        int randValue = rand() % 2;  // 0~1
        switch (randValue)
        {
        case 0:
            inventory[i] = new Weapon();
            break;
        case 1:
            inventory[i] = new Armor();
            break;
        }
    }
    
    
    for (int i = 0; i < 20; i++)
    {
        Item* item = inventory[i];
        if (item == nullptr)
            continue;

        if (item->_itemType == IT_WEAPON)
        {
            Weapon* weapon = (Weapon*)item;
            cout << "Weapon Damage : " << weapon->_damage << endl;
        }
    }
}

 

실행화면

---

 

 

 

 

 

int main()
{
    for (int i = 0; i < 20; i++)
    {
        Item* item = inventory[i];
        if (item == nullptr)
            continue;

        //**  Virtual 함수 변경으로 delete item; 하나로 해결
        if (item->_itemType == IT_WEAPON)
        {
            Weapon* weapon = (Weapon*)item;
            delete weapon;
        }
        else
        {
            Armor* armor = (Armor*)item;
            delete armor;
        }        

        delete item;
    }

    // [결론]
    // - 포인터 vs 일반 타입 : 차이를 이해하자
    // - 포인터 사이의 타입 변환(캐스팅)을 할 때는 매우 매우 조심해야 한다!
    // - 부모-자식 관계에서 부모 클래스의 소멸자에는 까먹지 말고 virtual을 붙이자!!!  // 코딩 테스트와 면접 단골문제!

    return 0;
}

 

 

포인터 vs 일반 타입 : 차이를 이해하자

- 포인터 사이의 타입 변환(캐스팅)을 할 때는 매우 매우 조심해야 한다!
- 부모-자식 관계에서 부모 클래스의 소멸자에는 까먹지 말고 virtual을 붙이자!!!  

 

---

 

 

전체 코드

 

#include <iostream>
using namespace std;

// 타입 변환 (포인터)

class Knight
{
public:
    int _hp = 0;
};

class Item
{
public:
    Item()
    {
        cout << "Item()" << endl;
    }

    Item(int itemType) : _itemType(itemType)
    {

    }

    Item(const Item& item)
    {
        cout << "Item(const Item&)" << endl;
    }

    ~Item()
    {
        cout << "~Item()" << endl;
    }

public:
    int _itemType = 0;
    int _itemDbld = 0;

    char _cummy[4096] = {}; // 이런 저런 정보들로 인해 비대해진 아이템 클래스를 나타내기 위해 표시
};

enum ItemType
{
    IT_WEAPON = 1,
    IT_ARMOR =2,
};

class Weapon : public Item
{
public:
    Weapon() : Item(IT_WEAPON)
    {
        _itemType = 1;
        cout << "Weapon()" << endl;
    }

    ~Weapon()
    {
        cout << "~Weapon()" << endl;
    }

public:
    int _damage = 0;
};

class Armor : public Item
{
public:
    Armor() : Item(IT_ARMOR)
    {
        cout << "Armor()" << endl;
    }

    ~Armor()
    {
        cout << "~Armor()" << endl;
    }

public:
    int _defence = 0;
};


int main()
{
    // 연관성이 없는 클래스 사이의 포인터 변환 테스트
    {
        // Stack [ 주소 ] -> Heap [ _hp(4) ]
        Knight* knight = new Knight();

        // 암시적으로는 NO
        // 명시적으로는 OK

        // Stack [ 주소 ]
        // tem* item = (Item*)knight;
        // item->_itemType = 2;
        // item->_itemDbld = 1;

        delete knight;
    }

    // 부모 -> 자식 변환 테스트
    {
        Item* item = new Item();

        // [ [ Item ]  ]
        // [  _damage  ]
        Weapon* weapon = (Weapon*)item;  // 위험한 상황, 잘못된 코드
        Weapon->_damage = 10;            // 잘못된 메모리를 건드림, 잘못된 코드

        delete item;
    }


    // 자식 -> 부모 변환 테스트
    {
        // [ [ Item ]  ]
        // [  _damage  ]
        Weapon* weapon = new Weapon();

        // 암시적으로도 된다!
        Item* item = weapon;    // Item* item = (item*) weapon;  // (item*) 부분이 생략되어있다

        delete weapon;
    }


    // 명시적으로 타입 변환할 때는 항상 항상 조심해야 한다!
    // 암시적으로 될 때는 안전하다?
    // -> 평생 명시적으로 타입 변환(캐스팅)은 안 하면 되는거 아닌가?

    Item* inventory[20] = {};

    srand((unsigned int)time(nullptr));

    for (int i = 0; i < 20; i++)
    {
        int randValue = rand() % 2;  // 0~1
        switch (randValue)
        {
        case 0:
            inventory[i] = new Weapon();
            break;
        case 1:
            inventory[i] = new Armor();
            break;
        }
    }

    for (int i = 0; i < 20; i++)
    {
        Item* item = inventory[i];
        if (item == nullptr)
            continue;

        if (item->_itemType == IT_WEAPON)
        {
            Weapon* weapon = (Weapon*)item;
            cout << "Weapon Damage : " << weapon->_damage << endl;
        }
    }



    return 0;
}