[CPP Module] 03

필요한 개념정리

 

기본 규칙

Orthodox Canonical Form

module 02와 마친가지로

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

이 4가지를 포함하고 있어야한다.

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

---

ex00

 

endl 과 ‘\n’ 차이점

ex00에 들어가기에 앞서 갑자기 endl과 '\n'의 차이가 궁금해져서 알아보게되었다. 그래서 알아보니

std::cout << "hello" << std::endl;

std::cout << "world" << '\n';

위에 출력되는 두 문자열의 경우 출력값은 서로 똑같이 나오게된다. 하지만 내부적으로 보면 기능적인 부분에서 차이점이 생기게 되는데.

endl 같은 경우에는 ‘\n’과는 다르게 버퍼를 비우는 역할을 같이 진행하게 된다.

출처: TCP 스쿨

문자열을 출력할때에는 일일이 바로바로 출력이 되지않고 모와두었다가 버퍼라는 것을 사용해서 한번에 출력을 하게 되는데

( 버퍼를 사용하지않고 일일이 출력을 하게되면 버퍼에 모와서 출력하는 것보다 느리게 출력이 된다. )

endl같은 경우는 newline + 버퍼를 비우는 역할이 된 얘라고 생각을하면 된다.

---

ex01

기존에 만들어두었던 ClapTrap을 상속받는 ScavTrap을 생성해야한다.

 

상속이란.

class A
{
public:
	test();
}

class B : A
{
public:
	hi();
	// A클래스를 상속받은 클래스이기때문에 A클래스에 있는 test도 B클래스에서 사용가능.
}

c++에서의 상속은 기존에 클래스(A)를 새로운 클래스(B)가 상속을 받아서 A에 있는 것들을 사용할 수 있게 되는 것이 상속이라고 이야기를 한다.

접근 제한자 설명

private	오직 자신의 클래스안에서만 접근 가능
protected	자신을 상속하는 클래스까지만 접근 가능
public	어디서든 접근 가능

상속에는 위와같이 총 3가지의 접근 제한자가 있는데.

( private < protected < public 순서로 접근 범위가 넓다. )

#include <iostream>

class A
{
private:
	int a;
protected:
	int b;
public:
	int c;
};

class B : public A
{
public:
	void sum() {
		a = 10; // NO : private error
		b = 20; // OK
		c = 30; // OK
	}
	void print() {
		std::cout << a; // NO : private error
		std::cout << b; // OK
		std::cout << c; // OK
	}
};

int main(void)
{
	B b;
	std::cout << b.a << std::endl; // NO : private error
	std::cout << b.b << std::endl; // NO : protected error
	std::cout << b.c << std::endl; // OK
	return (0);
}

클래스를 상속받은 클래스는 기존의 클래스에서 private를 제외한 나머지 접근 제한자들을 사용할 수 있다.

class A
{
private:
	int a;
protected:
	int b;
public:
	int c;
};

class B : public A
{
// code
};

class C : protected A
{
// code
};

class D : private A
{
// code
};

위와 같은 형식처럼 상속을 받을 때 그냥 상속을 받는것이 아니라 접근 지정자를 지정해서 상속을 받을 수 있는데 해석을 해보자면

• class B : public A
  public 보다 접근 범위가 넓은 것들을 public 취급을 하겠다는 이야기이지만 public보다 접근 범위가 넓은 것은 없기 때문에 접근 범위 그대로 상속을 받겠다는 의미
• class C : protected A
  protected 보다 접근 범위가 넓은 것들이 protected 처리가 된다 ( public )
• class D : private A
  private 보다 접근 범위가 넓은 것들이 private 처리가 된다 ( public, protected )

 

 

virtual (가상함수)

가상함수란

부모클래스에서 상속받은 클래스를 재정의 할것이라고 정의해두는 함수

class A
{
protected:
	int a;
public:
	virtual void print() {
		std::cout << "this is class A" << std::endl;
	}
};

class B : public A
{
public:
	void print() {
		std::cout << "this is class B" << std::endl;
	}
};

int main(void)
{
	A a;
	B b;
	a.print(); // this is class A
	b.print(); // this is calss B

	return (0);
}

위와 같이 A를 상속받은 B 함수에서 같은 매개 함수의 내용의 변경이 필요한 경우에는 virtual을 함수 앞에 붙여
재정의할 함수라고 명시를 해주는 방식이다.

class A
{
public:
	A() {
		std::cout << "A Default constructor called" << std::endl;
	}
	~A() {
		std::cout << "A Destructor called" << std::endl;
	}
};

class B : public A
{
public:
	B() {
		std::cout << "B Default constructor called" << std::endl;
	}
	~B() {
		std::cout << "B Destructor called" << std::endl;
	}
};

int main(void)
{
	B b;

	return (0);
}

// print : A Default constructor called
//         B Default constructor called
//         B Destructor called
//         A Destructor called

위와 같은 코드에서 B의 경우에는 A를 상속받아서 생성이 된 코드이기때문에 class B를 생성하고 소멸하는 과정에서는 A의 생성자와 소멸자가 둘 다 실행이 된다.

스택의 방식처럼 선입후출로 부모 → 자식순으로 실행이 되고 종료가 될때는 자식 → 부모순으로 진행이된다.

// 지정을 해준 경우 

class A
{
protected:
	std::string	name;
public:
	A() {
		std::cout << "A Default constructor called" << std::endl;
	}
	A(std::string name) {
		this->name = name;
		std::cout << name << " Default constructor called" << std::endl;
	}
	~A() {
		std::cout << "A Destructor called" << std::endl;
	}
};

class B : public A
{
public:
	B() {
		std::cout << "B Default constructor called" << std::endl;
	}
	B(std::string name) : A(name) {
		this->name = name;
		std::cout << name << " Default constructor called" << std::endl;
	}
	~B() {
		std::cout << "B Destructor called" << std::endl;
	}
};

int main(void)
{
	B b("Hi");

	return (0);
}

// print : Hi Default constructor called
//         Hi Default constructor called
//         B Destructor called
//         A Destructor called

특별히 값을 받는 생성자의 경우에는 어떠한 생성자를 상속받아서 실행을 할 것인지를 따로 자식 클래스에서 지정을 해줘야한다. 이 작업을 하지않으면 상속을 받은 자식 클래스는 부모 클래스의 기본형의 생성자가 실행이 된다.

// 지정을 안해준 경우

class A
{
protected:
	std::string	name;
public:
	A() {
		std::cout << "A Default constructor called" << std::endl;
	}
	A(std::string name) {
		this->name = name;
		std::cout << name << " Default constructor called" << std::endl;
	}
	~A() {
		std::cout << "A Destructor called" << std::endl;
	}
};

class B : public A
{
public:
	B() {
		std::cout << "B Default constructor called" << std::endl;
	}
	B(std::string name) {
		this->name = name;
		std::cout << name << " Default constructor called" << std::endl;
	}
	~B() {
		std::cout << "B Destructor called" << std::endl;
	}
};

int main(void)
{
	B b("Hi");

	return (0);
}

// print : A Default constructor called
//         Hi Default constructor called
//         B Destructor called
//         A Destructor called

---

ex02

ex01와 이하동문, ClapTrap을 상속받는 FragTrap을 생성해야한다.

ex01과 다른점은 void attack( const std::string& target ); 을 가상함수로 받지않고,
construction/destruction와 void highFivesGuys(void); 를 생성하면 된다.