C++ - Module 04

Subtype polymorphism, abstract classes, interfaces

과제는 ex00부터 ex03까지 있다.

Exercise 00: Polymorphism (다형성!)

Turn-in directory : ex00/
Files to turn in : Makefile, main.cpp, Every other files you need
Forbidden functions : None

For every exercise, your main must test everything.
Constructors and destructors of each class must have specifics output.
Create a simple and complete base class Animal.
The animal class got one protected attribute:

모든 예제를, 너의 메인문에서 테스트 해봐야한다.
서로다른 클래스들은 생성자 그리고 소멸자에서 각자 개성있는 출력을 뱉는다.
간단하고 완전한 클래스 animal 을 만듭니다.
animal 클래스는 하나의 protected 를 가진다.

• std::string type;

Create a class Dog that inherits from Animal.
Create a class Cat that inherits from Animal.
(for the animal class the type can be left empty or put at any value).
Every class should put their name in the Type field for example:
The Dog class type must be initialized as "Dog".
Every animal must be able to use the method makeSound().
This method will display an appropriate message on the standard outputs based on the
class.
Dog 를 생성하는데, Animal에서 상속 받는다.
Cat 을 생성하는데, Animal에서 상속 받는다.
(동물 클래스의 type은 비어두거나, 다른 값을 넣어둘수 잇다.
Dog클래스 type는 Dog로 초기화 해주어야한다.
모든 동물은 makeSound라는 메소드를 사용할수 있어야한다.
메소느는 클래스 기반 적절한 소리를 화면에 출력해야한다.

This should output the specific makeSound of the Dog and cat class, not the animal
one.
To be sure you will create a WrongCat class that inherits a WrongAnimal class that will
output the WrongAnimal makeSound() when test under the same conditions.
너는 wrong Cat클래스를 만들어야한다. WrongAnimal에서 상속 받는다.

Exercise 01: I don’t want to set the world on fire

Turn-in directory : ex01/
Files to turn in : Makefile, main.cpp, plus the needed files for your tests
Forbidden functions : None

You’ll reuse the Ex00 classes.
Create one class called Brain.
Brain will contain an array of 100 std::string called ideas
Now, Dog and cat will have a private Brain* attribute.

Ex00 클래스를 재사용합니다.
Brain이라는 클래스를 하나 만듭니다.
브레인에는 100개의 string 배열이 들어가 있다.
이제, 개 그리고 고양이는 private Brain *attribute를 가지고 있다.

Not every animal got a brain! 모든 동물이 뇌를 가지고 있지 않다.

Upon construction Dog and Cat will initialize their Brain* with a new Brain();
Dog 그리고 Cat생성시 그들의 Brain을 상속 받는다. new Brain() 과 함께

Your main will create and fill an Array of Animal half of it will be Dog and the other
half will be Cat.
너는 메인에서 Animal 배열을 생성할수 있고, 그리고 배열을 절반은 개 절반은 고양이로 채우다.

Before exit, your main will loop over this array and delete every Animal.
You must delete directly Cat and Dog as an Animal.
끝나기 전에, 너의 메인은 이 배열을 반복문 돌면서 모두 delete해줘야한다.

A copy of a Cat or Dog must be "deep".
Your test should show that copies are deep!
A copy 고양이나 개의 복사본은 "deep"이여야한다.
당신의 copies가 deep하다는걸 보여주세요

Constructors and destructors of each class must have specifics output.
The appropriate destructors must be called.
생성자 그리고 소멸자는 서로다른 출력을 뱉어야한다.
적절한 소멸자를 뱉어야한다.

Exercise 02: abstract class (추상 클래스)

Turn-in directory : ex02/
Files to turn in : Makefile, main.cpp, plus any needed files
Forbidden functions : None

A general Animal doesn’t make sense after all.
For example, it makes no sound!
To avoid any future mistakes, the default animal class should not be instantiable.
Fix the Animal class so nobody instantiates it by mistakes.
The rest should work as before.

결국은 animal을 만들지 않습니다.
예를 들어, 소리를 만들지 않기 떄문에,
앞으로의 실수를 예방하기 위해, 기본 animal클래스는 인스턴스화 하지 않는다. (animal tmp 이런식으로 인스턴스를 만들지 않습니다.)
animal클래스를 아무것도 인스턴스화 하지말고
나머지는 이전과 같이 일해야 합니다.

Exercise 03: Interface & recap ( 인터페이스 및 요약 )

Interface & recap
Turn-in directory : ex03/
Files to turn in : Makefile, main.cpp, plus any needed files
Forbidden functions : None

There’s no interface in C++98 (not even in C++20) but it’s common to call pure abstract
class Interface. So for this last exercise let’s try interfaces and recap everything!
c++ 98에는 인터페이스(순수 가상 메서드만 있는 클래스)가 없습니다. 그러나! 순수 추상 클래스 인터페이스를 호출하는 것이 일반적입니다.그래서 마지막 예제에서는 인터페이스를 연습해보자!

Complete the definition of the following AMateria class, and implement the necessary member functions.
Amateria 클래스 정의를 완료하세요, 그리고 필요한 멤버함수를 구현하세요!!!!

class AMateria
{
protected:
[...]
public:
AMateria(std::string const & type);
[...]
std::string const & getType() const; //Returns the materia type
virtual AMateria* clone() const = 0;
virtual void use(ICharacter& target);
};

Create the concrete Materias Ice and Cure . Their type will be their name in
lowercase ("ice" for Ice, etc...).
콘크리트의 재료인 Ice그리고 Cure를 생성해!. 그들의 타입은 소문자로한다. ("ice for Ice, etc...).

Their clone() method will, of course, return a new instance of the real Materia’s
type.
그들은 clone() 메소드를 가진다. 리턴으로 진짜 Materai의 타입을 가진 새로운 인터페이를ㄹ 반환합니다.

Regarding the use(ICharacter&) method, it’ll display:
• Ice: " shoots an ice bolt at NAME "
• Cure: " heals NAME’s wounds "
(Of course, replace NAME by the name of the Character given as parameter.)

사용 메소드에 관하여, 그들은 화면에 표시한다:
• Ice: " shoots an ice bolt at NAME "
• Cure: " heals NAME’s wounds "
(물론, NAME은 지정된 변수값을 넣어주세요.)

While assigning a Materia to another, copying the type doesn’t make
sense...

Materia 를 할당하는 동안, type를 복사하는것은 의미가 없습니다.

Create the Character class, which will implement the following interface:

Character클래스를 생성한다,다음기능들을 구현할

class ICharacter
{
public:
	virtual ~ICharacter() {}
	virtual std::string const & getName() const = 0;
	virtual void equip(AMateria* m) = 0;
	virtual void unequip(int idx) = 0;
	virtual void use(int idx, ICharacter& target) = 0;
};

The "Character" possesses an inventory of 4 Materia at most, empty at the start. He’ll
equip the Materia in slots 0 to 3, in this order.
캐릭터는 최대 4개의 Materia를 포함할수 있고 처음에는 비웠다.
그는 슬롯 0에서 3까지 마테리아를 이 순서로 장착합니다.

In case we try to equip a Materia in a full inventory, or use/unequip a nonexistent
Materia, don’t do a thing.
인벤토리가 가득찼을 때, Materia를 장착하려는 경우 또는 또는 존재하지 않는 Materia를 장착하거나 해제하는경우 아무것도 하지 마세요.

The unequip method must NOT delete Materia!
장비해제 메소드는 delete Materia해서는 안됩니다.(헤제한다고 free시키면 안된다는듯.)

The use(int, ICharacter&) method will have to use the Materia at the idx slot,
and pass target as parameter to the AMateria::use method.

use(int, ICharacter&) 메소드는 idx 슬롯에서 Materia 를 사용합니다. 그리고 use메소드에 매개변수로 target을 전달합니다.

Of course, you’ll have to be able to support ANY AMateria in a
Character’s inventory
물론, 너는 캐릭터 인벤토리에서 AMateria를 지원할수 있습니다.

Your Character must have a constructor taking its name as a parameter. Copy or
assignation of a Character must be deep, of course. The old Materia of a Character
must be deleted. Same upon the destruction of a Character .

너의 캐릭터는 이름을 매게변수로 사용하는 생성자를 가집니다. 캐릭터의 복사 또는 할당은 깊어야합니다. 오래된 Materia는 캐릭터에서 delete합니다. 캐릭터 파괴시에도 동일.

Create the MateriaSource class, which will have to implement the following interface:
MateriaSource 클래스 만들기, 다음 인터페이스를 구현해야합니다.

class IMateriaSource
{
public:
virtual ~IMateriaSource() {}
virtual void learnMateria(AMateria*) = 0;
virtual AMateria* createMateria(std::string const & type) = 0;
};

learnMateria must copy the Materia passed as a parameter, and store it in memory
to be cloned later. Much in the same way as for Character , the Source can know at
most 4 Materia, which are not necessarily unique.
learnMateria는 매개변수로 전달된 Materia를 복사하고 그리고 나중에 복제할수 있도록 메모리에 저장해야합니다.
캐릭터도 거의 같은 방식으로, 소스를 알수 있게 최대 4개의 Materia를 해야합니다. 고유할 필요는 없습니다.

createMateria(std::string const &) will return a new Materia, which will be a
copy of the Materia (previously learned by the Source) which type equals the parameter.
Returns 0 if the type is unknown.

createMateria는 새로운 Materia를 반환합니다. 어느 Materia를 카피할수 잇다. type매게변수도 같고 리턴값은 0입니다. 만약 type이 unknown이면 0을 반환합니다.

In a nutshell, your Source must be able to learn "templates" of Materia and re-create
them on demand. You’ll then be able to create a Materia without knowing its "real" type,
just a string identifying it.

간단히 말해서, 너의 소스는 Meteria의 templates를 배울수 있어야한다. 그리고 필요에 따라 재생성할수 있어야합니다. 너는 type을 모른체 Materia 를 생성할수 있습니다. 단지 그것을 식별하는 문자열.