[CPP Module] 04

기본 규칙

Orthodox Canonical Form

• 생성자
• 복사 생성자
• 복사 할당 생성자
• 소멸자

이 4가지를 포함

• include guards
• 코드 분할을 위해 필요한 경우 추가파일 사용가능
• C++ 역시 new를 사용하면 메모리 누수가 발생될 수 있기때문에 메모리에 대한 누수방지를 해줘야한다

 

ex00 : Polymorphism

상속이라는 개념을 응용해서 써보는 과제

new

c언어의 malloc이나 free와 똑같이 c++에도 동적할당으로 메모리를 할당하고 해지하는 것이 존재한다.

new의 경우에는 생성자를 호출하고, delete의 경우에는 소멸자를 호출한다.

class* a = new class; // 생성자 호출
.
.
.
delete a; // 소멸자 호출

위와 같은 형식으로 메모리를 할당하거나 해제를 진행한다.

동적할당을 왜 해야하는가?

int a[5];

위와 같은 방법이랑 malloc, free or new, delete와 똑같이 동작은 하지만 위와 같은 방법으로 계속 메모리를 미리 할당을 시켜버리면 프로그램이 끝날때까지 계속 메모리를 먹고있으니 그만큼 메모리의 효율은 떨어지게된다.

그래서 동적할당이라는 것을 사용하여 사용할때만 malloc이나 new등으로 메모리를 잡았다가 필요없으면 free나 delete로 메모리 할당을 해제하는 것이 더 효율적이다.

업 캐스팅(up casting), 다운 캐스팅(down casting)

업 캐스팅 (up casting)

class Animal {
	// ...
};

class Cat : public Animal {
	// ...
};

int main(void) {

	const Animal* temp = new Cat();
    
    return 0;
}

Animal
  |
 Cat

위에있는 class가 위와 같은 형식으로 상속이 이루어지고 있을때 cat이라는 클래스가 animal이라는 클래스로 업 캐스팅이 이루어진 상황으로 temp라는 class는 부모클래스의 멤버에만 접근이 가능하게 된다.

다운 캐스팅 (down casting)

// error
Animal *a = new Animal();
Cat c = (Cat) a;

// answer
Animal* a = new Cat();
Cat c = (Cat) a;

다운 캐스팅은 말 그대로 부모클래스 → 자식클래스 형태로 형변환을 하는 것을 의미한다.

전자 같은 경우에는 부모클래스를 자식클래스가 상속받아져 있는 상황에서는 자식클래스가 부모클래스보다 가지고 있는 정보가 많은 상황이 보통이루어진다.

그때 부모클래스를 자식클래스로 다운캐스팅을 해버리면 부모클래스의 정보만으로는 자식클래스가 구성될 수 없기때문에 오류가 발생이 되는 형식이다.

그래서 다운캐스팅을 하고싶으면 후자와 같이 업캐스팅이 선행된 이후가 사용을 해야한다.

[Java] 업캐스팅과 다운캐스팅

---

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

클래스안에서 다른 클래스를 가지는 클래스를 만들어보는 것

깊은 복사라는 것을 이해하고 사용해보기

leaks 확인

system("leaks a.out");

위와 같은 형식의 코드를 종료 직전에 넣어두면 메모리 누수가 발생하는지 안하는지 등을 system에서 실행하여 해당부분을 확인해준다.

double free 확인방법 (메모리 버그 디렉터)

-g3 -fsanitize=address

위와 같은 플래그 옵션을 넣어서 컴파일을 진행해보면 double free등 프로그램의 문제가 뭐때문에 발상이 되어 도중에 종류가 되었는지를 확인할 수 있는 옵션

( 위와 같은 사진처럼 어디서 오류가 발생하였고 왜 발생하였는지 오류를 알려준다. )

깊은 복사와 앝은 복사

문제에서는 객체가 복사가 shallow copy가 아닌 deep copy를 하도록 요구를 하고 있다.

여기에서 깊은 복사와 앝은 복사는 무엇이고 차이점은 무엇인가?

앝은 복사 ( shallow copy )

실제 데이터가 아닌 메모리의 주소만을 복사

class	*test = new class();
class	*copy = new class();

*test = *copy;

delete test;
delete copy;

// [1] 80684 segmentation fault

앝은 복사를 진행한 경우에 위에 코드를 진행할 경우 test와 copy모두 1개의 값을 가르키고 있기때문에

값은 값을 delete를 2번 진행시켜 segmentation fault error가 발생이된다.

그래서 test의 값을 바꾸거나 copy의 값을 변경하면 변경된 값이 모두에게 적용이 된다.

깊은 복사 ( deep copy )

값 자체를 복사

class	*test = new class();
class	*copy = new class();

*test = *copy;

delete test;
delete copy;

// not error

내부적으로 코드를 어떻게 구성하냐에 따라 깊은 복사를 진행한 경우에는 앝은 복사와는 다르게 test와 copy가 각자 서로 다른 주소값의 값을 들고 있기때문에 delete를 2번 진행해도 error없이 코드가 진행이 이루어진다.

내부적으로 코드를 어떻게 구성하냐에 따라 앝은 복사와 다르게 test와 copy가 서로 다른 주소값을 가지고 있기때문에 값을 바꾸어도 각자만 값이 변경이 된다.

---

ex02 : Abstract class

abstract class 추상 클래스에 대해서 다루는 파트

pure virtual function (순수 가상 함수)

파생 클래스에 의해 재정의되어야 하는 함수

virtual void test() = 0;

함수를 선언만 하고 사용하지 않은 상태로 해당함수를 가지고있는 클래스를 상속받은 자식 클래스에서 재선언 후에 사용하는 함수 (해당 함수는 선언만 되어있고 안에 내용이 없다는 의미에서 선언부 끝에 “= 0;”형식으로 표시를 해준다.)

virtual void test();

위와 같은 형식으로 상속받은 자식 클래스에서 함수의 내용을 재 선언해줘야한다.

abstract class (추상 클래스)

하나 이상의 순수 가상 함수를 포함하고 있는 클래스를 추상 클래스라고 부른다.

class Test 
{
private:
public:
	virtual void sound() = 0; // 순수가상함수
};

class Test 
{
private:
public:
	virtual void sound() = 0;
};

class Copy : public Test
{
public:
	virtual void sound() {
		std::cout << "Hello";
	}
};

int main(void)
{
	Copy copy;
	copy.sound(); // output : "Hello"
	return (0);
};

위와 같이 Test 클래스를 Copy 클래스가 상속받은 경우에는 Test클래스안에 있는 순수가상함수인 sound()를

선언 해줘야한다.

선언을 해주지않은 경우

unimplemented pure virtual method 'sound' in 'TestTwo’

가상함수를 만들어두고 상속받은 자식 클래스에서 따로 선언을 해주지않게되면 해당 함수를 찾을 수 없다고하며 오류가 발생된다.

추상클래스 사용용도

추상클래스의 경우에는 이름에서 보이다시피 구현이 완벽하지 않아 독단적으로 사용이 불가능하고 하위클래스의 설계 또는 가이드라인을 주는 역할만 하는 클래스로 사용된다.

class Test 
{
private:
public:
	virtual void sound() = 0;
};

int		main(void)
{
	Test test; // error

	return (0);
}

위와 같이 선언을 해서 사용을 할려고하면 추상클래스라 불가능하다는 문구가 나온다.

virtual, override 차이점

class Test 
{
private:
public:
	virtual void sound() = 0;
};

// ===== override =====

class TestOne : public Test
{
public:
	void sound() override { // override
		std::cout << "TestOne";
	}
};

// ===== virtual ======

class TestTwo : public Test
{
public:
	virtual void sound() { // virtual
		std::cout << "TestTwo";
	}
};

int		main(void)
{
	TestOne one;
	TestTwo two;

	one.sound(); // output : "TestOne"
	two.sound(); // output : "TestTwo"

	return (0);
}

위와 같이 TestOne과 TestTwo에서는 각각 Test라는 클래스를 상속받아 override 해주었는데

one은 override사용하였고, two는 virtual 사용하였다.

두가지 모두 기능적으로는 똑같이 작동을 하는데 어떤 부분에서 차이점이 생기는지 비교해보았다.

override

C++11 버전 이상부터 사용가능한 키워드로 상속을 받는 클래스에서 override를 받을 것을 명시해주는 역할을 한다.

class Test 
{
private:
public:
	virtual void sound() = 0;
};

// ===== override =====

class TestOne : public Test
{
public:
	void sound() const override { // const로 수정 : error
		std::cout << "TestOne";
	}
};

위와같이 상속받은 순수가상함수를 임의적으로 변경을 하면 error를 내보내서 내부적으로 방지를 해주는 역할

그치만 해당방법은 자주 사용을 하는거같지는 않다.. 왜지?

virtual

class Test 
{
private:
public:
	virtual void sound() = 0;
};

class TestTwo : public Test
{
public:
	virtual void sound() { // virtual
		std::cout << "TestTwo";
	}
};

상속을 받는 클래스에서는 virtual를 안적어도 특별한 오류가 발생하지는 않지만

상속을 해주는 클래스뿐만 아니라 상속을 받는 클래스에서도 명시적으로 virtual를 적어주는것이 좋은 코드라고한다.

Cat *cat = new Cat();
Dog *dog = new Dog();

Animal *cat = new Cat();
Animal *dog = new Dog();

Cat *cat = new Cat(); 위와 같은 방법에 경우는

virtual ~Animal();

소멸자 또한 virtual로 선언이 되어있다면 자식클래스의 소멸자만 동작을 해야하는건 아닌지?

부모소멸자와 자식소멸자가 모두 동작이 된다면 왜 되는건지?

---

ex03 : Interface & recap

해당 과제에서는 지금까지 배웠던 개념들을 응용해서 조금 더 복잡하고 다양하게 상속을 해보는 파트

새로운 개념이 필요했던 파트는 아니지만

기존에 배웠던 개념들을 응용하고 확실하게 사용해봐라 라는 느낌에 과제였던거같다.

해당 과제에서는 7개의 클래스를 정의해야한다.

• ICharacter
• Character
• IMateriaSource
• MateriaSource
• AMateria
• Ice
• Cure

각각 설명을 해보자면

ICharacter, IMateriaSource 는 interfaces 형식으로 사용이 될 얘들이고

Character에는 ICharacter 이라는 interfaces를 상속 받아서 사용하며 기본적인 user에 해당하는 값들이 담긴다.

user는 MateriaSource를 통해 만들어지는 ice와 cure를 AMateria를 통해서 user에게 전달이 가능하고 해당 원소들을 전달받은 user는 원소들을 사용할 수 있다.

전방선언

// AMateria.hpp
class AMateria
{
public:
	virtual void use(ICharacter& target);
	...
};

// ICharacter.hpp
class ICharacter
{
public:
	virtual void equip(AMateria* m) = 0;
	...
};

ICharacter와 AMateria는 서로를 내부 매개함수에서 서로의 클래스를 사용하고 있어서 서로를 참조하게 되어 컴파일이 진행이 되지않는다.

// ICharacter.hpp

class AMateria;

class ICharacter
{
public:
	virtual void equip(AMateria* m) = 0;
	...
};

이 부분을 해결해주기위해서 전방선언이라는 방식을 사용해서 클래스를 사용하기 전에 미리 임시선언을 해주면 서로를 인식해서 오류가 발생되지않게 된다.