Gyong

객체 포인터

-> 객체 포인터 변수에 본인 또는 본인을 상속 받는 객체의 주소를 저장할 수 있다.

-> 반대의 경우는 불가능하다.

class CObj
{
public:
	void CObj_Func()
	{

	}
};
class CPlayer : public CObj
{
public:
	void CPlayer_Func()
	{

	}
};

CPlayer* pObj1 = new CObj; // 불가능

단, 객체의 멤버에 접근할 때는 객체 타입 기본으로 판단한다.

객체 타입         
 CObj*		pObj = new CObj;
 CObj*		pPlayer = new CPlayer;

pPlayer의 실 객체는 CPlayer 이지만
객체 타입이 CObj이기 때문에 CObj가 가지고 있는 함수만 호출이 가능하다.

pPlayer->CObj_Func();
pPlayer->CPlayer_Func();		// 불가능

하지만 객체 타입이 CPlayer 이면 자식 클래스이기 때문에 부모 클래스에 있는 함수까지 호출이 가능하다.

CPlayer	  player;
player.CObj_Func();
player.CPlayer_Func();

객체 타입을 자식클래스로 하면 부모 클래스로 동적 할당이 불가능하다.

자식 -> 부모는 참조가 가능하지만 부모 -> 자식은 불가능.

하지만 부모 클래스가 자식 클래스를 참조하는 방법이 있다.

가상 함수를 이용하는 것이다.(virtual)

상속

-> 부모 클래스가 가진 것을 자식 클래스에게 물려주는 것.

-> 프로그래밍에서 물려주는 것은 복사 후 붙여넣기 이다.

상속을 구현할 때 자식 클래스에서 어떤 부모클래스를 상속 받을지 명시한다.

class 자식클래스명 : 부모클래스명

상속의 조건

-> 부모 클래스를 상속 받을 때 어떤 조건으로 상속 받을지 설정할 수 있다.

-> 조건(기본 접근 지정자)을 설정하지 않을 경우 기본 private 형태로 상속을 받는다.

class A(부모)
{
public:
  void A_Func()
  {
  
  }
};

class B(자식) : public A(부모)
{
public:
  void B_Func()
  {
  
  }
}

상속 관계에서의 생성자와 소멸자 호출 순서.

생성 과정
객체 생성 -> 메모리 할당 -> 부모 생성자 호출 -> 자식 생성자 호출

소멸 과정
자식 소멸자 호출 -> 부모 소멸자 호출 -> 메모리 반환 -> 객체 소멸

상속의 관계

-> 상속 관계를 구성할 때 조건에 맞도록 구성해야한다.

#1. is-a 관계 

Object is a Player
-> 오브젝트는 플레이어다.
모든 오브젝트가 플레이어가 아니다! -> 문장이 성립하지 않는다.

Player is a Object
-> 플레이어는 오브젝트이다.
문장이 성립한다.

#2. has-a 관계
Player is a Sword
-> 플레이어는 검이다!
문장이 성립하지 않는다.

Sword is a Player
-> 검은 플레이어이다!
문장이 성립하지 않는다.

Player has a Sword
-> 플레이어는 검을 가진다.
문장이 성립된다.

다중 상속이란?
-> 다중 상속을 이용하면 여러 클래스들을 상속 받을 수 있다.

class CAxe
{
public:
	void Swing()
	{
		cout << "CAxe Swing" << endl;
	}
};

class CSword
{
public:
	void Swing()
	{
		cout << "CSword Swing" << endl;
	}
};

class CPlayer : public CSword, public CAxe
{
public:
	CSword	m_Sword;
	CAxe		m_Axe;
};

-> 단, 다중 상속은 모호성이 가장 큰 문제이다.

CPlayer	 player;
player.Swing();

플레이어는 검과 도끼를 상속 받은 상태이다.
이후 Swing을 호출할 때 검의 Swing인지 도끼의 Swing인지 알 수 없는 상황이 발생한다.

이를 방지하기위해서 has-a 관계가 성립될 경우에는 상속을 받지 않고, 포함 관계로 구성하는 것이 좋다.

포함 관계란?
-> 상속을 받는 것이 아니라, 멤버로 객체를 포함시키는 것이다.

class CPlayer
{
public:
	CSword	m_Sword;
	CAxe		m_Axe;
};

friend

-> private의 접근 권한을 타 클래스에게 허용하는 문법

-> 은닉화를 위반하는 문법이라 잘 사용하지않음.

friend를 사용하여 다른 클래스 호출

#include "Girl.h"
class CBoy
{
public:
	CBoy();
	CBoy(int _a, int _b);
	~CBoy();

public:
	void Func();
	void Girl_Func(CGirl* _girl);

private:
	int		m_iA;
	int		m_iB;


	friend class CGirl;	
};

friend를 사용하여 다른 클래스 안에 있는 함수 호출

#include "Girl.h"
class CBoy
{
public:
	CBoy();
	CBoy(int _a, int _b);
	~CBoy();

public:
	void Func();
	void Girl_Func(CGirl* _girl);

private:
	int		m_iA;
	int		m_iB;

	
	friend void CGirl::Boy_Func(CBoy* _boy);
};

friend 함수에서 호출된 클래스에서 호출한 클래스의 멤버 변수 및 함수에 접근이 가능하게된다.

CGirl : 호출된 클래스

CBoy : 호출한 클래스

this 포인터

-> this가 사용된 객체의 주소를 저장하고 있다.

-> 다음과 같이 CObj의 객체를 통해서 확인을 해보면 주소가 같은 것을 확인할 수가 있다.

class CObj
{
public:
	void Func()
	{
		cout << "this: " << this << endl;
	}
};

void main()
{	
	CObj	obj1;
	CObj	obj2;

	cout << "&obj1: " << &obj1 << endl;
	obj1.Func();
	cout << "----------------------------------" << endl;
	cout << "&obj2: " << &obj2 << endl;
	obj2.Func();
}

this 포인터의 사용

class CObj
{
public:
	CObj() : m_pBuff(nullptr) {}
	CObj(char* _pBuff)
	{
		this->m_pBuff = new char[strlen(_pBuff) + 1];
		strcpy_s(this->m_pBuff, strlen(_pBuff) + 1, _pBuff);
	}
	~CObj()
	{
		if (this->m_pBuff)
		{
			delete[] this->m_pBuff;
			this->m_pBuff = nullptr;
		}
		cout << "소멸자 호출" << endl;
	}
}

extern 키워드

-> 외부파일(.cpp 또는 .h) 어딘가에 전역 변수가 존재한다고 알려주는 역할을 한다.

#include "stdafx.h"

extern int a;

void main()
{
	cout << a << endl;
}

-> extern 키워드는 보통 찾아내기 쉽게 헤더 파일을 따로 만들어서 명시해놓는다고 한다.

#pragma once
#ifndef __EXTERN_H__
#define __EXTERN_H__

extern int a;

endif//!__EXTERN_H__

extern 키워드를 사용할 때는 아무 cpp 파일에 해당 자료형과 변수의 이름을 똑같이 전역 변수로 선언을 해야한다.

그렇지 않으면 링커 오류가 발생한다.