20 분 소요

Java


개요

오늘은 과제 마감 기간은 이미 훌쩍 지났지만, 2학년 1학기 자료구조 2번째 과제를 제출한 결과물과 그 과정에서 있었던 일들을 적어보려고 한다.

과제 2 (4점)

과제의 명세는 이러하다. ***

프로그램 3.6과 3.7을 완성하여라. 프로그램 조건 및 테스트 방법은 아래와 같다.

  1. 게임 캐릭터 클래스를 정의한다.

    Character 클래스

    • 추상 클래스로 정의한다.
    • 캐릭터 이름, 레벨, 힘, 민첩, 지능, 공격력, 방어력, 체력, 정신력 수치를 저장하는 멤버변수를 갖는다. 단, 캐릭터 이름은 동적 메모리에 할당하여 저장한다.

    Warrior, Archer, Sorcerer 클래스

    • Character 클래스를 상속한다.
    • 무기 이름을 멤버변수로 갖는다. 단, 무기 이름은 동적 메모리에 할당하여 저장한다.


  • Warrior는 객체 생성 시 캐릭터 이름과 무기 이름을 입력받으며, 그 외의 멤버변수는 다음과 같이 디폴트 값으로 설정된다.
    • 레벨 : 1, 힘 : 100, 민첩 : 50, 지능 : 20, 공격력 : 5, 방어력 : 3, 체력 : 80, 정신력 : 20
  • Archer는 객체 생성 시 캐릭터 이름과 무기 이름을 입력받으며, 그 외의 멤버변수는 다음과 같이 디폴트 값으로 설정된다.
    • 레벨 : 1, 힘 : 50, 민첩 : 100, 지능 : 20, 공격력 : 5, 방어력 : 3, 체력 : 50, 정신력 : 50
  • Sorcerer는 객체 생성 시 캐릭터 이름과 무기 이름을 입력받으며, 그 외의 멤버변수는 다음과 같이 디폴트 값으로 설정된다.
    • 레벨 : 1, 힘 : 20, 민첩 : 50, 지능 : 100, 공격력 : 5, 방어력 : 3, 체력 : 20, 정신력 : 80

모든 객체의 move 함수는 “이동했습니다”를 출력한다. 모든 객체의 showInfo 함수는 캐릭터 이름, 무기 이름, 레벨, 힘, 민첩, 지능, 공격력, 방어력, 체력, 정신력의 수치를 출력한다.

Warrior 객체의 attack 함수는 “(무기 이름)칼로 찔렀습니다.”를 출력한다.
Archer 객체의 attack 함수는 “(무기 이름)화살을 쐈습니다.”를 출력한다.
Sorcerer 객체의 attack 함수는 “(무기 이름)마법을 걸었습니다.”를 출력한다.


  1. 프로그램 3.6에서 Bag 용량(capacity)의 초기값은 10이 아닌 3으로 수정한다.

  2. 프로그램 3.7에서 Bag의 생성자, 소멸자, Size(), IsEmpty(), Element(), Push(), Pop() 구현한다.
    3.1 Element() 연산은 배열 임의의 위치에 있는 원소를 리턴한다.
    3.2 Pop() 연산은 배열 임의의 위치에 있는 원소를 삭제한다.
    3.3 필요한 경우 교재의 멤버함수 코드를 변경 및 추가한다.

  3. Character 객체를 저장하기 위한 Bag 객체를 생성한다. 빈 Bag에 대해 Size(), IsEmpty() 결과를 출력한다.

  4. Push()를 3번 수행하여 Warrior, Archer, Sorcerer 객체를 3개 추가한 후, Size(), IsEmpty(), Element() 결과를 출력한다. Element()의 경우, 리턴된 객체에 대해 showInfo(), move(), attack() 결과를 출력한다.

  5. Push()를 6번 수행하여 Warrior, Archer, Sorcerer 객체를 각각 2개씩 추가한 후, Size(), IsEmpty(), Element() 결과를 출력한다. Element() 연산의 경우, 리턴된 객체에 대해 showInfo(), move(), attack() 결과를 출력한다.

  6. Pop()을 2번 수행하여 객체를 2개 삭제한 후, Size(), IsEmpty(), Element() 결과를 출력한다. Element() 연산의 경우, 리턴된 객체에 대해 showInfo(), move(), attack() 결과를 출력한다.


구현 여부 항목(점수가 부여된 각 항목에 대해 O, X로 모두 표기할 것)

  1. 게임 클래스 구현 여부
    • Character 클래스를 추상 클래스로 구현 여부(0.25점)
    • Warrior, Archer, Sorcerer 클래스의 상속 여부(0.25점)
    • 생성자, 소멸자, move, showInfo, attack 구현 여부(각 0.3점씩 총 1.5점)
  2. Bag 클래스 템플릿 구현 여부
    • 생성자, 소멸자, Size, IsEmpty, Element(임의의 위치), Push, Pop(임의의 위치) 구현 여부 (0.1, 0.1, 0.1, 0.1, 0.2, 0.1, 0.2점씩 총 0.9점)

  3. 2번 항목 수정 여부(0.1점)

  4. 배열 확장 기능 구현 여부(1점)

제출 파일 : 학번_2.cpp, 출력 결과와 구현 여부를 명시한 문서 파일(문서 파일명은 임의로)을 압축 파일로 제출(압축 파일명은 임의로)

프로그램 구현

Bag 템플릿 클래스

과제 명세 첫 줄에 프로그램 3.6과 3.7을 완성하라는 문구가 있었고, 교수님이 대면 강의에서 과제에 대해 설명하실 때에도 이미 구현된 코드가 많기 때문에 이번 과제 완성이 쉬울 것이라고 얘기하셔서 일단 프로그램 3.6과 3.7의 코드를 보기로 했다.

프로그램 3.6

프로그램 3.6은 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

template <class T>
class Bag
{
public:
  Bag (int bagCapacity = 10);
  ~Bag(); 
  
  int Size() const;  
  bool IsEmpty() const; 
  T& Element() const;  
  
  void Push(const T&); 
  void Pop(); 

private:
  T *array;
  int capacity; 
  int top; 
};

Bag의 템플릿 클래스에 대한 코드이다. Bag 클래스의 멤버 변수와 함수들이 선언되어 있다.

프로그램 3.7

프로그램 3.7은 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

template <class T>
Bag<T>::Bag (int bagCapacity): capacity ( bagCapacity ) {
  if (capacity < 1) throw "Capacity must be > 0";
  array = new T[capacity];
  top = -1;
}

template <class T>
Bag<T>::~Bag() {delete [ ] array; }

template <class T>
void Bag<T>::Push(const T& x) {
  if (capacity ==top+1) 
  {
    ChangeSize1D(array, capacity, 2 * capacity);
    capacity *=2;
  }
  array[++top] = x;
}

template <class T>
void Bag<T>::Pop() {
  if (IsEmpty()) throw "Bag is empty, cannot delete";
  int deletePos = top / 2;
  copy(array+deletePos+1,array+top+1,array+deletePos);
      // compact array
  array[top--].~T();   // destructor for T
}

Bag의 멤버 함수들 중 일부만 구현되어 있다. 문제 3번 항목에 따라서 우리는 Bag의 생성자, 소멸자, Size(), IsEmpty(), Element(), Push(), Pop() 을 구현해야 하니, 이미 구현된 생성자, 소멸자, Push(), Pop() 외에 Size(), IsEmpty(), Element() 3개의 함수만 더 구현하면 된다.

Size()와 IsEmpty() 는 강의 자료에 나와있었어서 그냥 그대로 적을 수 있었다.
Element() 함수는 조건 3.1에 의해 랜덤 함수를 써야 했는데 사용법이 기억이 안 나서 구글링을 했다.

랜덤 함수 쓰는 법

참고 링크

요약하자면 C에서 랜덤 함수를 사용하기 위해서는 rand, srand, time 함수 세 가지가 필요하다.

rand, srand 함수를 사용하기 위해서는 stdlib.h 헤더파일을, time 함수를 사용하기 위해서는 time.h라는 헤더파일을 include 해야 한다.

rand 함수는 int형을 리턴하며, seed 값을 결정하는 srand 함수에 의해서 난수 생성 값이 정해져버리기 때문에 우리가 원하는 진짜 랜덤값을 얻기 위해서는 항상 바뀌는 시간을 이용하여 시드 값을 매번 다른 값으로 갱신시켜줘야만 한다.

Bag 템플릿 클래스 구현하기

이를 토대로 작성한 Size, IsEmpty, Element 함수는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//사이즈 Size()
template <typename T>
int Bag<T>::Size() const { return top + 1; }

//비었니? IsEmpty
template <typename T>
bool Bag<T>::IsEmpty() const { return Size() == 0; }

//랜덤 원소 리턴 Element
template <typename T>
T& Bag<T>::Element() const {
    if (IsEmpty()) throw "Bag is empty";
    srand(time(NULL));
    int randomIndex = rand() % (top + 1);
    return array[randomIndex];
}


Bag 클래스의 전체 코드는 다음과 같다. (최종본 아님, 자세한 건 후술)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//클래스 Bag 템플릿
template <typename T>
class Bag {
public:
    Bag(int bagCapacity = 3);
    ~Bag();
    
    int Size() const;
    bool IsEmpty() const;
    T& Element() const;
    
    void Push(const T&);
    void Pop();

private:
    T *array;
    int capacity;
    int top;
};

//생성자
template <typename T>
Bag<T>::Bag(int bagCapacity): capacity(bagCapacity) {
    if (capacity < 1) throw "Capacity must be > 0";
    array = new T[capacity];
    top = -1;
}

//소멸자
template <typename T>
Bag<T>::~Bag(){
    delete[] array;
}

//사이즈 Size()
template <typename T>
int Bag<T>::Size() const { return top + 1; }

//비었니? IsEmpty
template <typename T>
bool Bag<T>::IsEmpty() const { return Size() == 0; }

//랜덤 원소 리턴 Element
template <typename T>
T& Bag<T>::Element() const {
    if (IsEmpty()) throw "Bag is empty";
    srand(time(NULL));
    int randomIndex = rand() % (top + 1);
    return array[randomIndex];
}

//배열에 원소 넣기 Push
template <typename T>
void Bag<T>::Push(const T& x) {
    if (capacity == top + 1)
    {
        T* oldArray = array;
        capacity *= 2;
        array = new T[capacity];
        for (int i = 0; i <= top; i++)
            array[i] = oldArray[i];
        delete[] oldArray;
    }
    array[++top] = x;
}

//랜덤 원소 삭제 Pop
template <typename T>
void Bag<T>::Pop() {
    if (IsEmpty()) throw "Bag is empty, cannot delete";
    srand(time(NULL));
    int deletePos = rand() % (top + 1);
    copy(array + deletePos + 1, array + top + 1, array + deletePos);
    top--;
}

Bag 클래스가 제대로 구현되었는지 확인해보기 위해서 int형 Bag을 만들어 문제 조건과 똑같이 테스트를 해보았다.

메인 함수는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

int main(void)
{
    Bag<int> bag;

    cout << "Size: " << bag.Size() << endl;
    cout << "IsEmpty: " << bag.IsEmpty() << endl;

    const int a = 3;
    const int b = 4;
    const int c = 1;
    bag.Push(a);
    bag.Push(b);
    bag.Push(c);

    cout << "Size: " << bag.Size() << endl;
    cout << "IsEmpty: " << bag.IsEmpty() << endl;
    cout << "Element: " << bag.Element() << endl;

    const int d = 9;
    const int e = 15;
    const int f = 7;
    const int g = 5;
    const int h = 20;
    const int i = 30;
    bag.Push(d);
    bag.Push(e);
    bag.Push(f);
    bag.Push(g);
    bag.Push(h);
    bag.Push(i);

    cout << "Size: " << bag.Size() << endl;
    cout << "IsEmpty: " << bag.IsEmpty() << endl;
    cout << "Element: " << bag.Element() << endl;

    bag.Pop();
    bag.Pop();

    cout << "Size: " << bag.Size() << endl;
    cout << "IsEmpty: " << bag.IsEmpty() << endl;
    cout << "Element: " << bag.Element() << endl;

    return 0;
}

실행결과 :

음, 아주 정상적으로 잘 작동되는군! 이제 Character 클래스를 만들어서 합쳐보자.
(이때까지만 해도 나는 이후에 엄청난 문제가 발생할 것이라는 것을 인지하지 못했다…)

게임 캐릭터 클래스

사실부터 말하겠다. 과제 기간이 빠듯해서 챗 gpt에게 엄청 도움 받았다…

작년, 코로나로 인해 프로그래밍 기초 강의가 녹화 강의로 진행됐었기 때문에 내가 이해 못했더라도 다시 돌려보면 되니까 잘 몰랐었는데, 이 교수님 수업 꽤나 지루하다…

내용이 조금 어렵기도 해서 강의 내용을 하나도 모른 상태에서 과제를 진행하려니까 막막했다.
그래서 gpt에게 코드를 부탁한 다음에 수정을 하려고 했는데, 내용을 모르니까 이 과정이 굉장히 오래걸렸다.

Character 추상 클래스 구현

일단 Character는 캐릭터 이름, 레벨, 힘, 민첩, 지능, 공격력, 방어력, 체력, 정신력 수치를 멤버변수로 가져야 한다.
추상 클래스이고 Warrior, Archer, Sorcerer가 상속을 할 예정이니까 접근 지정자는 protected로 선언하자.

1
2
3
4
5
6
7
8
9
10

protected:
    char * name = NULL;
    int level;
    int str;
    int dex;
    int intelligence;
    int op;
    int dp;
    int hp;
    int mp;

name을 포인터 변수로 선언한 이유는 1번 조건에 따라 생성자가 호출될 때 캐릭터 이름을 동적 할당 하기 위해서이다.


이제 생성자를 통해서 멤버 변수를 초기화 시키도록 하자.
멤버 이니셜라이저를 사용하고, name은 생성자 안에서 strlen을 통해 길이를 구한 다음, 이름 문자열을 동적 할당하고, 할당된 메모리에 문자열을 복사해주자.

1
2
3
4
5
6
7

public:
    Character(char * name, int myLevel, int myStr, int myDex, int myIntelligence, int myOp, int myDp, int myHP, int myMp)
    : level(myLevel), str(myStr), dex(myDex), intelligence(myIntelligence), op(myOp), dp(myDp), hp(myHP), mp(myMp){
        const int lenName = strlen(name) + 1;
        this->name = new char[lenName];
        strcpy(this->name, name);
    }


이제 소멸자, move, showInfo, attack 가상 함수 선언을 해주면 완성된 코드는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//캐릭터 클래스 정의
class Character{
protected:
    char * name = NULL;
    int level;
    int str;
    int dex;
    int intelligence;
    int op;
    int dp;
    int hp;
    int mp;

public:
    Character(char * name, int myLevel, int myStr, int myDex, int myIntelligence, int myOp, int myDp, int myHP, int myMp)
    : level(myLevel), str(myStr), dex(myDex), intelligence(myIntelligence), op(myOp), dp(myDp), hp(myHP), mp(myMp){
        const int lenName = strlen(name) + 1;
        this->name = new char[lenName];
        strcpy(this->name, name);
    }
    virtual void move() const { }
    virtual void showInfo() const { }
    virtual void attack() const { }
    virtual ~Character(){
        delete name;
    }
};

Warrior, Archer, Sorcerer 클래스 구현

이 3개의 클래스들은 하나만 잘 구현한 뒤에 복붙 후 약간의 데이터만 바꿔주면 된다.
일단 Warrior 클래스를 기준으로 먼저 구현을 해보자.


Warrior 클래스는 Character 클래스를 상속하니 부모 클래스의 멤버들은 모두 갖고 있을 것이고, 멤버 변수로는 무기 이름만 따로 만들어주면 될 것 같다.

1
2
3

class Warrior : public Character{
    private:
        char * weapon;

위에서 name 만드는 것과 똑같은 방법으로 private 변수를 만들어주고,
생성자도 비슷한 방법으로 만들어주자.

1
2
3
4
5
6

public:
        Warrior(char * name, char * weapon) : Character(name, 1, 100, 50, 20, 5, 3, 80, 20) {
            const int lenWeapon = strlen(weapon) + 1;
            this->weapon = new char[lenWeapon];
            strcpy(this->weapon, weapon);
        }

위의 코드처럼 자식 클래스가 부모 클래스의 생성자를 호출하는 구조는 추상 클래스의 전형적인 특징이니 기억해두도록 하자.
옆의 숫자들은 Warrior의 레벨, 힘, 민첩 등의 스텟 디폴트 값이다.


이제 소멸자, move, showInfo, attack 함수를 구현해주면 Warrior 클래스의 완성된 코드는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

//워리어 클래스
class Warrior : public Character{
    private:
        char * weapon;

    public:
        Warrior(char * name, char * weapon) : Character(name, 1, 100, 50, 20, 5, 3, 80, 20) {
            const int lenWeapon = strlen(weapon) + 1;
            this->weapon = new char[lenWeapon];
            strcpy(this->weapon, weapon);
        }

        virtual void move() const {
        cout << "이동했습니다." << endl;
        }

        virtual void showInfo() const {
            cout << "캐릭터 이름: " << name << endl;
            cout << "무기 이름: " << weapon << endl;
            cout << "레벨: " << level << endl;
            cout << "힘: " << str << endl;
            cout << "민첩: " << dex << endl;
            cout << "지능: " << intelligence << endl;
            cout << "공격력: " << op << endl;
            cout << "방어력: " << dp << endl;
            cout << "체력: " << hp << endl;
            cout << "정신력: " << mp << endl;
        }

        virtual void attack() const {
            cout << weapon << "칼로 찔렀습니다." << endl;
        }

        virtual ~Warrior() {
            delete weapon;
        }
};

남은 Archer, Sorcerer 클래스도 위 코드와 똑같이 만든 다음 값만 조금 수정해주면 끝.

문제 발생

자! 이제 게임 캐릭터도 다 만들었으니, 템플릿으로 아까 테스트했던 int 대신 Character 형 변수를 넣으면 과제 끝이다~~~

….?
자료형만 바꿔 넣었을 뿐인데 내 코드가 오류 범벅이 되어 버렸다.

아니 Bag이랑 Character 각각은 잘 돌아가는데, 왜 합치니까 문제가 발생하는 건데요…
template은 모든 자료형을 다 받을 수 있는 거 아니었나? 교수님이 예제 프로그램을 잘못 알려주신 건가?
아니다. 분명 문제는 나한테 있을 것이다.

오류는 Bag 클래스의 생성자에서 new로 배열을 할당하는 코드에서 발생됐는데, 나는 과제 마감일까지 도저히 이 문제의 원인을 발견하지 못했고, 결국 오류를 해결하지 못한채 각각의 구현 결과만을 보여주는 main 함수만 작성하여 과제를 제출하고야 말았다…

이 오류를 과제 마감 3시간 전에 알게 되어서 과방에서 마감 시간 1분 전에 보고서를 제출하고 심장이 쿵쾅거렸던 기억이 아직까지 생생하다.

이름도 모르는 같은 과 동기가 과방에서 그 애 친구들끼리 같은 과제를 하고 있다가 포인터로 바꿔야 한다는 얘기를 어렴풋이 들었지만, 마감까지 얼마 안 남았는데 친하지도 않은 사람 붙잡고서 물어보는 건 너무 추해가지고 미완성인 과제를 제출한 뒤 과방에서 나와 지하철 막차를 타러 내려가는 길에 에타에서 해당 문제에 대한 해답을 뜻밖에 얻게 되었다.


Bag의 자료형을 Charater로 받게 되면 array = new T[capacity]; 문장이 실행될 때, new 구문에서 Character의 생성자가 호출되게 되고, Character 클래스는 추상 클래스이므로 생성자를 호출해서는 안 된다.

특정 클래스 T를 상속받는 다양한 클래스 객체를 담는 배열을 생성하는 것이 불가능한 이유는 C++의 메모리 관리 방식 때문이다.
C++에서 배열을 생성할 때는 자료형을 지정해야 하는데, 이는 각 원소가 메모리에서 차지하는 크기를 알기 위해서이다. 이를 통해 배열을 생성할 때 메모리에 저장된 크기만큼의 공간을 할당하게 된다. 클래스 T를 상속받는 다양한 클래스를 저장하는 데에 필요한 크기는 클래스마다 다를 것이다. 즉, 지정된 크기를 알 수가 없다는 뜻이다.

따라서, C++에서는 다양한 하위클래스를 원소로 갖는 배열을 생성할 수 없다.
그럼 어떻게 해야 할까? C++에서는 하위클래스를 배열로 만들어 관리할 수 없는 걸까?

답은 포인터다. 클래스 T의 주소를 갖는 포인터 배열은 생성할 수 있다. 왜냐하면 포인터는 언제나 크기가 정해져 있으니까.

문제 해결

Bag 클래스의 생성자를 수정하는 것이 아니라,
Bag 클래스로 만든 bag 객체의 자료형을 Character형이 아니라 Character*형으로 바꾼다면 모든 문제가 해결되는 것이었다.

또 한가지, 자료형이 동적 할당된 객체라면 배열에서 객체가 사라질 때, 즉 Pop() 함수가 실행될 때 소멸자가 호출되어야 하므로 Pop()에서
top–;
이 문장을 array[top–].~T(); 로 바꿔야 한다.

이제야 이 과제에 담긴 교수님의 참뜻을 이해할 수 있게 되었다.
1장에서 배웠던 new 연산자의 의미와 올바른 사용법부터, 클래스의 생성자와 소멸자의 올바른 사용법, 상속받은 클래스의 생성자 정의법, 상속 관계에서의 객체 포인터 변수의 정확한 의미 및 사용 범위, 가상 함수의 오버라이딩, 가상 소멸자 사용 방법, 클래스 템플릿, 자료구조 Bag. 지금까지 배웠던 모든 것을 써먹어야만 풀 수 있는 문제였던 것이다. ㄱㅇㅅ 당신은 도대체….

최종 완성된 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cstring>

using namespace std;

//클래스 Bag 템플릿
template <typename T>
class Bag {
public:
    Bag(int bagCapacity = 3);
    ~Bag();
    
    int Size() const;
    bool IsEmpty() const;
    T& Element() const;
    
    void Push(const T&);
    void Pop();

private:
    T *array;
    int capacity;
    int top;
};

//생성자
template <typename T>
Bag<T>::Bag(int bagCapacity): capacity(bagCapacity) {
    if (capacity < 1) throw "Capacity must be > 0";
    array = new T[capacity];
    top = -1;
}

//소멸자
template <typename T>
Bag<T>::~Bag(){ delete[] array; }

//사이즈 Size()
template <typename T>
int Bag<T>::Size() const { return top + 1; }

//비었니? IsEmpty
template <typename T>
bool Bag<T>::IsEmpty() const { return Size() == 0; }

//랜덤 원소 리턴 Element
template <typename T>
T& Bag<T>::Element() const {
    if (IsEmpty()) throw "Bag is empty";
    srand(time(NULL));
    int randomIndex = rand() % (top + 1);
    return array[randomIndex];
}

//배열에 원소 넣기 Push
template <typename T>
void Bag<T>::Push(const T& x) {
    if (capacity == top + 1)
    {
        T* oldArray = array;
        capacity *= 2;
        array = new T[capacity];
        for (int i = 0; i <= top; i++)
            array[i] = oldArray[i];
        delete[] oldArray;
    }
    array[++top] = x;
}

//랜덤 원소 삭제 Pop
template <typename T>
void Bag<T>::Pop() {
    if (IsEmpty()) throw "Bag is empty, cannot delete";
    srand(time(NULL));
    int deletePos = rand() % (top + 1);
    copy(array + deletePos + 1, array + top + 1, array + deletePos);
    array[top--].~T();
}

//캐릭터 클래스 정의
class Character{
protected:
    char * name = NULL;
    int level;
    int str;
    int dex;
    int intelligence;
    int op;
    int dp;
    int hp;
    int mp;

public:
    Character(const char * name, int myLevel, int myStr, int myDex, int myIntelligence, int myOp, int myDp, int myHP, int myMp)
    : level(myLevel), str(myStr), dex(myDex), intelligence(myIntelligence), op(myOp), dp(myDp), hp(myHP), mp(myMp){
        const int lenName = strlen(name) + 1;
        this->name = new char[lenName];
        strcpy(this->name, name);
    }
    virtual void move() const { }
    virtual void showInfo() const { }
    virtual void attack() const { }
    virtual ~Character(){
        delete name;
    }
};

//워리어 클래스
class Warrior : public Character{
    private:
        char * weapon = NULL;

    public:
        Warrior(const char * name, const char * weapon) : Character(name, 1, 100, 50, 20, 5, 3, 80, 20) {
            const int lenWeapon = strlen(weapon) + 1;
            this->weapon = new char[lenWeapon];
            strcpy(this->weapon, weapon);
        }

        virtual void move() const {
        cout << "이동했습니다." << endl;
        }

        virtual void showInfo() const {
            cout << "캐릭터 이름: " << name << endl;
            cout << "무기 이름: " << weapon << endl;
            cout << "레벨: " << level << endl;
            cout << "힘: " << str << endl;
            cout << "민첩: " << dex << endl;
            cout << "지능: " << intelligence << endl;
            cout << "공격력: " << op << endl;
            cout << "방어력: " << dp << endl;
            cout << "체력: " << hp << endl;
            cout << "정신력: " << mp << endl;
        }

        virtual void attack() const {
            cout << weapon << "칼로 찔렀습니다." << endl;
        }

        virtual ~Warrior() {
            delete weapon;
        }
};

//아처 클래스
class Archer : public Character{
    private:
        char * weapon = NULL;

    public:
        Archer(const char * name, const char * weapon) : Character(name, 1, 50, 100, 20, 5, 3, 50, 50) {
            const int lenWeapon = strlen(weapon) + 1;
            this->weapon = new char[lenWeapon];
            strcpy(this->weapon, weapon);
        }

        virtual void move() const {
            cout << "이동했습니다." << endl;
        }

        virtual void showInfo() const {
            cout << "캐릭터 이름: " << name << endl;
            cout << "무기 이름: " << weapon << endl;
            cout << "레벨: " << level << endl;
            cout << "힘: " << str << endl;
            cout << "민첩: " << dex << endl;
            cout << "지능: " << intelligence << endl;
            cout << "공격력: " << op << endl;
            cout << "방어력: " << dp << endl;
            cout << "체력: " << hp << endl;
            cout << "정신력: " << mp << endl;
        }

        virtual void attack() const {
            cout << weapon << "화살을 쐈습니다." << endl;
        }

        virtual ~Archer() {
            delete weapon;
        }
};

//소서러 클래스
class Sorcerer : public Character{
    private:
        char * weapon = NULL;

    public:
        Sorcerer(const char * name, const char * weapon) : Character(name, 1, 20, 50, 100, 5, 3, 20, 80) {
            const int lenWeapon = strlen(weapon) + 1;
            this->weapon = new char[lenWeapon];
            strcpy(this->weapon, weapon);
        }

        virtual void move() const {
        cout << "이동했습니다." << endl;
    }

        virtual void showInfo() const {
            cout << "캐릭터 이름: " << name << endl;
            cout << "무기 이름: " << weapon << endl;
            cout << "레벨: " << level << endl;
            cout << "힘: " << str << endl;
            cout << "민첩: " << dex << endl;
            cout << "지능: " << intelligence << endl;
            cout << "공격력: " << op << endl;
            cout << "방어력: " << dp << endl;
            cout << "체력: " << hp << endl;
            cout << "정신력: " << mp << endl;
        }

        virtual void attack() const {
            cout << weapon << "마법을 걸었습니다." << endl;
        }

        virtual ~Sorcerer() {
            delete weapon;
        }
};

int main(void)
{
    Bag<Character*>* bag = new Bag<Character*>();
    Character * element = NULL;

    cout << "**빈 Bag 생성**" << endl;
    cout << "Size: " << bag->Size() << endl;
    cout << "IsEmpty: " << bag->IsEmpty() << endl << endl;

    Warrior * leonard = new Warrior("레오나드", "우르");
    Archer * weet = new Archer("위트", "보우");
    Sorcerer * ocon = new Sorcerer("오콘", "써클");
    bag->Push(leonard);
    bag->Push(weet);
    bag->Push(ocon);

    cout << "**3번 Push() 이후**" << endl;
    cout << "Size: " << bag->Size() << endl;
    cout << "IsEmpty: " << bag->IsEmpty() << endl << endl;
    element = bag->Element();
    element->showInfo();
    element->move();
    element->attack();

    Warrior * walter = new Warrior("월터", "비브라늄");
    Warrior * wooganda = new Warrior("우간다", "셀리스");
    Archer * legolas = new Archer("레골라스", "위프");
    Archer * lucas = new Archer("루카스", "신");
    Sorcerer * dexter = new Sorcerer("덱스터", "아토믹");
    Sorcerer * myrr = new Sorcerer("미르", "트렌스");
    bag->Push(walter);
    bag->Push(wooganda);
    bag->Push(legolas);
    bag->Push(lucas);
    bag->Push(dexter);
    bag->Push(myrr);

    cout << endl << "**6번 Push() 이후**" << endl;
    cout << "Size: " << bag->Size() << endl;
    cout << "IsEmpty: " << bag->IsEmpty() << endl << endl;
    element = bag->Element();
    element->showInfo();
    element->move();
    element->attack();

    bag->Pop();
    bag->Pop();
    
    cout << endl << "**2번 Pop() 이후**" << endl;
    cout << "Size: " << bag->Size() << endl;
    cout << "IsEmpty: " << bag->IsEmpty() << endl << endl;
    element = bag->Element();
    element->showInfo();
    element->move();
    element->attack();

    return 0;
}

Archer와 Sorcerer 클래스를 추가하였고, Pop() 함수를 수정했으며, 수정된 main 함수가 코드 끝부분에 존재한다.

main 함수에서 Elemnet() 함수는 Bag의 원소 중 하나의 원소의 주소를 리턴하기 때문에
그 리턴된 객체를 가리키는 Character 포인터 변수를 하나 선언하여 리턴 값을 받고난 후에 showInfo, move, attack 함수를 출력해야 한다.


실행결과 :

참고로 캐릭터 이름이랑 무기 이름은 우리 친형이 지어줬다. (무슨 뜻인지는 나도 몰라…)

후기

지금 와서 생각해보면 굉장히 쉬운 코드 한 줄만 바꾸면 해결되는 간단한 오류였는데, 이를 해결하지 못한 채로 과제를 제출한 게 정말 분하다.

공부를 미리 했었다면, 또 선형대수 중간고사가 끝나자마자 바로 시작했었더라면, 컴퓨터 구조 과제를 지난 주에 미리 끝내 놓았었더라면, 마감일에 과방 동기에게 눈 딱 감고 물어봤었더라면, 애초에 과제 기간이 6일이 아니라 조금 더 길었더라면…

수많은 후회가 남지만, 모두 내 잘못이니까 더 할 말이 없고, 더 분한 것 같다.
여태까지 프로그래밍은 당연하고, 과제를 완성하지 못한 채로 제출했던 적이 없었는데 느슨했던 대학생활에 긴장감을 줬던 과제였다.

앞으로 과제는 꼭 미리미리 하자. 또 그날 수업에서 모르는 부분이 있었다면 놓친 부분이 있었다면 당일에 바로바로 공부해놓자.

이래저래 나에게 많은 반성과 깨달음과 또 지식적으로 배움을 안겨준 귀중한 과제 기간이 아니었나 생각해본다.

댓글남기기

참고