꽈이의 게임개발

Atomic

꽈이렁 — Tue, 25 Feb 2025 23:38:07 +0900

Atomic이란?

Atomic은 멀티스레드 환경에서 데이터를 안전하게 관리할 수 있도록 보장하는 기능이다.
일반적인 변수는 여러 스레드에서 동시에 접근하면 데이터 경쟁(Race Condition)이 발생할 수 있지만,
Atomic 변수는 원자적 연산(Atomic Operation)을 통해 이러한 문제를 방지한다.

Atomic의 특징

원자성(Atomicity)
- 연산이 쪼개지지 않고 한 번에 수행된다.
- 실행 도중 다른 스레드가 개입할 수 없다.
데이터 경쟁 방지
- 여러 스레드가 동시에 접근해도 안전하게 값을 변경할 수 있다.
잠금 없는 동기화(Lock-free Synchronization)
- 일반적인 mutex 같은 락을 사용하지 않아 성능이 향상된다.

Atomic 연산

함수설명

load()	현재 값 읽기
store(x)	값 설정
fetch_add(x)	현재 값에 x를 더하고 이전 값 반환
fetch_sub(x)	현재 값에서 x를 빼고 이전 값 반환
exchange(x)	현재 값을 x로 바꾸고 이전 값 반환

Atomic의 활용

멀티스레드 카운터
로그 시스템 (동시 접근 방지)
락 없는 자료구조 (예: 락-프리 큐)

Atomic을 사용하면 데이터 경쟁을 방지하면서도 성능을 최적화할 수 있다.
멀티스레드 프로그래밍에서 꼭 필요한 개념이므로, 상황에 맞게 활용하는 것이 중요하다.

테스트 해보자

#include "pch.h"
#include <iostream>
#include <thread>
#include <atomic>

static atomic<int> tempNum = 0;

void Add()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		tempNum++;
	}
}


void Sub()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		tempNum--;
	}
}

int main()
{

	std::thread t1(Add);
	std::thread t2(Add);
	t1.join();
	t2.join();
	cout << tempNum << endl;
}

결과값

아토믹을 사용한 tempNum 변수는 정확하게 2000000이라는 값이 나왔다.

아토믹은 mutex와 같이 LOCK ,UNLOCK 과정이 필요없지만

만능은 아니다 아토믹은 모든 자료형에 사용이 가능할까?

아토믹의 정의를 살펴보자

is_trivially_copyable_v<_Ty> 아토믹은 단순 복사가 가능해야하고
is_copy_constructible_v<_Ty> 복사생성이 가능해야하고
is_move_constructible_v<_Ty> 이동 생성이 가능해야하고
is_copy_assignable_v<_Ty> 복사 할당이 가능해야하고
is_move_assignable_v<_Ty> 이동 할당이 가능해야한다

위 조건을 만족하지 않으면 컴파일 에러가 발생한다.

쓰레드 thread

꽈이렁 — Tue, 25 Feb 2025 02:08:25 +0900

전 글에서 프로세스와 쓰레드의 차이점을 정리해보았다.

예제 코드를 작성해보자

#include "pch.h"
#include <iostream>
#include <thread>

static int tempNum = 0;

void Add()
{
	for (int i = 0; i < 1000000; i++)
	{
		tempNum++;
	}
}


void Sub()
{
	for (int i = 0; i < 1000000; i++)
	{
		tempNum--;
	}
}

int main()
{
	cout << tempNum << endl;

	std::thread t1(Add);
	std::thread t2(Sub);
	t1.join();
	t2.join();
	cout << tempNum << endl;
}

static int tempNum = 0;
//tempNum이라는 전역변수를 0으로 초기화하고

cout << tempNum << endl;

//0으로 초기화된 tempNum 출력

std::thread t1(Add);
std::thread t2(Sub);

//tempNum을 백만번 증가시키는 쓰레드를 실행

//tempNum을 백만번 감소시키는 쓰레드를 실행

t1.join();
t2.join();

//t1 쓰레드가 종료될때까지 대기

//t2 쓰레드가 종료될때까지 대기

cout << tempNum << endl

쓰레드 실행이 완료된 상태에서 tempNum출력

결과는 어떻게 나올까?

0으로초기화하고

백만번더하면서 백만번을빼니까 정답은 0??

실제로 결과값은 0이 나오지않는다.

심지어 실행할때마다 결과값은 다르게 출력된다.

왜 이렇게될까?

실제로 백만번 1씩 증가시키는 부분의 어셈블리코드는 보면 위와같다

00007FF6EB922515 mov eax,dword ptr [tempNum (07FF6EB92F440h)]

//07FF6EB92F440h 의 주소에있는 데이터를 eax로 이동

00007FF6EB92251B inc eax

//eax값을 증가

00007FF6EB92251D mov dword ptr [tempNum (07FF6EB92F440h)],eax

//증가된 eax값을 다시 07FF6EB92F440h주소로 이동

우리가 코드를 작성할때에는 한줄로 tempNum++ 한줄로 표현하지만

실제로 코드가 돌아갈때에는

메모리에서 -> CPU로 값을 이동하고 -> 연산을 한 후에 -> 다시 CPU로 이동을 하는 행위를한다.

그럼 다시 쓰레드가 돌아가는 상황을 생각해보자

tempNum은 0이다.

Add thread> tempNum에 있는 데이터를 CPU a위치로 옮겼다. 옮겨진 값은 0이다.

Sub thread> tempNum에있는 데이터를 CPU b위치로 옮겼다. 옮겨진 값은 0이다.

Add thread> a위치의 값을 +1했다 연산된 값은 +1이다
Sub thread> b위치의 값을 -1했다 연산된 값은 -1이다

Add thread> +1된 데이터를 다시 tempNum 메모리 위치로 옮긴다. tempNum은 +1이다
Sub thread> -된 데이터를 다시 tempNum 메모리 위치로 옮긴다. tempNum은 -1이된다.

위 스탭은 예시이다 실제로 저렇게 드라마틱하게 한단계씩 실행되지는않는다.

위 예시에서 중요한점은

Add Thread에서 연산된값은 Sub쓰레드에서 연산된 값으로 덮혔다는것이다.

위와같은 행위가 계속 반복되면서

백만번 더하고 백만번 빼는것같지만 0이라는 결과값이 나오지 않는것이다.

위와같은 행위를 해결할 수 있는 방법이 동기화이다.

다음글에서 설명이어서 하겠습니다.

프로세스? 쓰레드?

꽈이렁 — Tue, 25 Feb 2025 01:45:28 +0900

클라이언트 프로그래머의 서버 공부 시작글입니다.

다시 기초부터 시작합니다..

C++ 프로세스와 쓰레드의 차이

C++에서 프로세스(Process)와 쓰레드(Thread)는 모두 실행 단위를 의미하지만, 동작 방식과 사용 목적이 다릅니다.

1. 프로세스(Process)란?

프로세스는 운영체제(OS)에서 실행 중인 프로그램을 의미합니다.

각각의 프로세스는 독립적인 메모리 공간(주소 공간)을 가짐
다른 프로세스와 메모리를 공유하지 않음
프로세스 간의 통신(IPC, Inter-Process Communication)은 추가적인 작업이 필요함

프로세스의 특징

독립적인 실행 단위
운영체제가 직접 관리
하나의 프로세스가 종료되어도 다른 프로세스에 영향을 주지 않음
실행 속도가 비교적 느림 (프로세스 간 문맥 전환 비용이 큼)

2. 쓰레드(Thread)란?

쓰레드는 프로세스 내에서 실행되는 작은 실행 단위입니다.

하나의 프로세스 내에서 여러 개의 쓰레드를 가질 수 있음 (멀티쓰레딩)
같은 프로세스의 메모리를 공유 (데이터 영역, 힙 영역 등)
하지만 각각의 쓰레드는 독립적인 스택(Stack)과 레지스터(Register)를 가짐

쓰레드의 특징

같은 프로세스 내에서 동작
메모리 공유로 인해 빠른 데이터 교환 가능
실행 속도가 빠름 (쓰레드 간 문맥 전환 비용이 적음)
하지만 동기화 문제(Race condition, Deadlock 등)가 발생할 수 있음

3. 프로세스와 쓰레드의 차이 비교

비교 항목프로세스(Process)쓰레드(Thread)

실행 단위	독립적인 실행 단위	프로세스 내부의 실행 단위
메모리 구조	독립적인 메모리 공간	프로세스의 메모리 공유
통신 방식	프로세스 간 통신(IPC) 필요	메모리를 공유하여 빠른 데이터 전달 가능
실행 속도	느림 (문맥 전환 비용 큼)	빠름 (문맥 전환 비용 적음)
안정성	하나의 프로세스가 죽어도 다른 프로세스에 영향 없음	하나의 쓰레드 오류가 프로세스 전체에 영향을 줄 수 있음
활용 예시	운영체제 프로세스, 대형 애플리케이션	멀티쓰레딩 서버, 게임 엔진

4. C++에서 프로세스와 쓰레드 사용 방법

1) C++에서 프로세스 생성 (fork() - 리눅스)

C++에서는 보통 fork()를 사용하여 새로운 프로세스를 생성합니다.

fork()는 리눅스에서만 사용 가능하며, Windows에서는 CreateProcess()를 사용해야 합니다.

2) C++에서 쓰레드 생성 (std::thread)

C++11부터 std::thread를 사용하여 쉽게 멀티쓰레딩을 구현할 수 있습니다.

5. 언제 프로세스를 사용하고, 언제 쓰레드를 사용할까

프로세스가 적합한 경우

서로 독립적인 작업을 수행해야 할 때
보안적으로 분리된 환경이 필요할 때
크롬 브라우저처럼 여러 개의 독립적인 작업이 필요한 경우

쓰레드가 적합한 경우

같은 데이터를 여러 작업에서 공유해야 할 때
실행 속도가 중요한 멀티태스킹 프로그램 (ex: 게임, 웹 서버)
자원을 효율적으로 활용해야 할 때

6. 결론

프로세스는 서로 독립적인 실행 단위로 동작하며, 메모리를 공유하지 않음.
쓰레드는 같은 프로세스 내에서 실행되며, 메모리를 공유하여 빠르게 작업을 수행할 수 있음.
멀티쓰레딩은 성능을 향상시키지만 동기화 문제를 신경 써야 함.

따라서, 프로그램의 특성과 요구사항에 따라 적절한 방식을 선택하는 것이 중요합니다.

C++ goto (고투)

꽈이렁 — Thu, 14 May 2020 20:17:14 +0900

MSDN 설명

식별자에 의해 지정된 레이블 문은 현재 함수에 있어야 합니다. 모든 식별자 이름은 내부 네임스페이스의 멤버이므로 다른 식별자를 방해하지 않습니다.

문 레이블은에 의미가 goto 문과 그렇지 않은 경우 문 레이블은 무시 됩니다. 레이블을 다시 선언할 수 없습니다.

goto 해당 위치에 대 한 범위 내에 있는 모든 변수를 초기화 하는 메서드는 위치에 컨트롤을 전송 하는 문은 허용 되지 않습니다.

라고한다.

쉽게 말하면 그냥 내가 지정한 위치로 점프해버리는 제어문이다.

점프하고 싶은 곳에 comeback의 이름을가진 레이블을 만들고 goto comeback 을 하면 comeback 레이블이 있는곳으로 점프한다.

아래 코드를 보자

코드

#include <iostream>

int main()
{
	int x;
comeback :
	std::cout << "5이상 숫자 입력해" << std::endl;
	std::cin >> x;
	if (x < 5)
	{
		std::cout << "??????????????? ";
		std::cout << x;
		std::cout << " 5이상 이요!" << std::endl;
		goto comeback;
		std::cout << "이것도 출력해 보시지!" << std::endl;
	}
	else
	{
		std::cout << x << std::endl;
	}
	return 0;
}

결과

5이하의 숫자를 입력할때 comeback:의 위치로 점프해서 계속 반복하다가 5를 넣자 프로그램이 종료되었다!

goto 문 때문에 위로 다시 점프를 하기 때문에 이것도 출력해 보시지! 라는 문자는 출력되지 않는다.

지금은 레이블을 1개밖에 사용하지 않아서 편리해 보이지만.. 만약 레이블이 50개 100개 늘어난다고하면 어떻게 될까

엄청 얽혀 있고 프로그래머는 코드의 흐름을 이해하기 힘들어진다. 이런 코드를 스파게티 코드라고 하는데.

관리하기 어려운 코드가 된다는것이다. 그래서 C++에서는 잘 사용하지 않는다고 들었다!!

물론 사람마다 차이가 있기때문에 자주 사용하시는 분들도 있을것이다!

C++ 바이트패딩 Byte Padding (두번째!)

꽈이렁 — Wed, 13 May 2020 21:37:01 +0900

https://younggwan.tistory.com/41

C++ 바이트 패딩(Byte Padding)

바이트 패딩(Byte Padding) 클래스(구조체)에 패딩 바이트를 추가하여 CPU 접근을 더 용이하게 해주는 기법 코드 #include "pch.h" #include class TestClass { char m_Temp_Char[2]; int m_Temp_Int;..

younggwan.tistory.com

전에 바이트 패딩에 정리한적이있다.

가장큰 자료형의 크기로 바이트패딩이 된다고 말했었는데

좀더 정보를 추가하기 위해 2번째 글이다!.

일단 코드를 보자

class A
{
public:
	char m_c1; // 1
	char m_c2; // 1
	int  m_i1; // 4
	char m_c3; // 1
	int m_i2; // 4
	char m_c4; // 1

	virtual void Func()
	{

	}
};


int main()
{
	A a;
	a.m_c1 = 1;
	a.m_c2 = 2;
	a.m_i1 = 11;
	a.m_c3 = 3;
	a.m_i2 = 22;
	a.m_c4 = 4;
	A* a_p = &a;
	size_t tempsize = sizeof(A);
	return 0;
}

x64 환경에서 A의 크기는

가상 함수 포인터가 멤버 변수로 생기기에 8바이트로 패딩이 이루어 질거라고 예상을 하고
char, char, int, char, int, char 의 멤버 변수를 가지고있기에
1, 1, 4, 1, 4, 1
8(__vfptr) + 8(1,1,4,1), + 8(4,1) = 24의 사이즈가 나올거라고 예상을 했다.
하지만 사이즈가!

32바이트가 나왔다..

그래서! 메모리로 확인을 해보았다.

30 9c 99 28 f7 7f 00 00 01 02 cc cc 0b 00 00 00 03 cc cc cc 16 00 00 00 04 cc cc cc cc cc cc cc

----------------------------------------------------

__vfptr(30 9c 99 28 f7 7f 00 00)

----------------------------------------------------
m_c1(01)
m_c2(02)
cc
cc
m_i1(0b 00 00 00)

----------------------------------------------------

m_c3(03)
cc
cc
cc
m_i2(16 00 00 00)

----------------------------------------------------

m_c4(04)
cc
cc
cc
cc
cc
cc
cc

----------------------------------------------------

이렇게 메모리가 자리잡았다.

24바이트 크기안에 다넣을수있는데 왜 32바이트가 되었을까

바이트패딩은 이전의 데이터의 타입으로 바이트 패딩 규칙을 만든다고한다.

현재 가상 함수 포인터로 인하여 8바이트의 크기로 패딩이 되고있는데

char, char, int , char가 8바이트에 들어간게아니라

char 7바이트 남았네 또 char가 들어올수있네!
char 6바이트 남았네 또 char가 들어올수있네!
int 2바이트 남았네 또 int가 들어올수없네! 하나더!!!

char 7바이트 남았네 또 char가 들어올수있네!
int 3바이트 남았네 또 int가 들어올수없네! 하나더!!!!!!!!!!!

char 7바이트 남았네!

이런식으로 크기가 32바이트가 되었다고한다..

공부하다가 당연히 24라고 생각했었는데 32였다 하하하하하하....

역시 코딩은 의심에 의심에 의심에 의심을 해야겠다.

언제나 틀린정보는 지적해주시면 감사하겠습니다!. 꼭.. 잡아주세요

C++ void* 보이드 포인터

꽈이렁 — Mon, 11 May 2020 16:26:44 +0900

정의

MSDN에서 void에 정의는 다음과 같다

함수 반환 형식으로 사용 하는 경우 void 키워드는 함수가 값을 반환 하지 않도록 지정 합니다. 함수 매개 변수 목록에 사용 되는 경우 void 는 함수가 매개 변수를 사용 하지 않도록 지정 합니다. 포인터 선언에 사용 되는 경우 void 는 포인터가 "universal(만능)" 임을 지정 합니다.

포인터 형식이 void* 이면 포인터는 const 또는 volatile 키워드를 사용 하 여 선언 되지 않은 모든 변수를 가리킬 수 있습니다. Void* 포인터는 다른 형식으로 캐스팅 된 경우에만 역참조 될 수 있습니다. Void* 포인터를 다른 형식의 데이터 포인터로 변환할 수 있습니다.

Void 포인터는 함수를 가리킬 수 있지만의 C++클래스 멤버가 아니어야 합니다.

Void형식의 변수는 선언할 수 없습니다.

void pointer는 제네릭 포인터(generic pointer)라고 불린다.
모든 데이터 자료형을 가리킬 수 있는 포인터이다.

void* 는 다른 변수를 가리킬 수 있지만. 다른 형식으로 캐스팅 된 경우에만 역참조가 된다고 하고
const 또는 volatile 키워드로 사용 하여 선언 되지 않은 모든 변수를 가리킬 수 있다고 한다.
코드를 통해 보자.

#include <iostream>


class VP_TEST_CLASS
{

};

int main()
{
	int _i;
	short _s;
	VP_TEST_CLASS v_t_c;
	void* v_p;

	v_p = &_i;
	std::cout << *v_p << std::endl;
	v_p = &_s;
	std::cout << *v_p << std::endl;
	v_p = &v_t_c;
	std::cout << *v_p << std::endl;

	const int _c_i = 10;
	v_p = &_c_i;

	volatile int _v_i;
	v_p = &_v_i;


	return 0;
}

void* 는 모든 자료형을 가리키고 있지만
출력을 하려고 해도 void* 는 자료형의 객체를 알지 못하기 때문에 역참조가 불가능하다.
역참조를 하려면 void*를 다른 포인터의 유형으로 명시적 형 변환을 해야한다.

또한 const, volatile 형식의 변수는 void* 로 가리킬수 없다.

#include <iostream>


class VP_TEST_CLASS
{

};

int main()
{
	int _i = 20;
	short _s;
	VP_TEST_CLASS v_t_c;
	void* v_p;

	int* _i_p;
	v_p = &_i;
	_i_p = static_cast<int*>(v_p);
	std::cout << *_i_p << std::endl;
	return 0;
}

또한 포인터 산술에서도 void*는 되지않는다 포인터 산술은 포인터가 어떤 크기의 객체를 가리키는지 알아야 하므로 포인터를 더하거나 뺄수없는 void*는 포인터 연산이 되지않는다.

#include <iostream>

int main()
{
	int _i = 20;

	void* v_p;
	int* i_p;

	v_p = &_i;
	i_p = &_i;

	v_p++;
	i_p++;

	return 0;
}

또한 void reference 보이드 참조도 안된다!

#include <iostream>

int main()
{
	int _i = 20;

	void* v_p;
	int* i_p;

	void& r_p = _i;
	int& r_i = _i;

	return 0;
}

C++ 함수 포인터

꽈이렁 — Tue, 5 May 2020 22:57:28 +0900

C++의 특징이라고 한다면 포인터를 말할 수 있다.
그럼 함수도 포인터로 이용할 수 있지 않을까??

정의

포인터는 다른 변수의 주소를 저장하는 변수이다.
함수 포인터는 다른 함수의 주소를 저장하는 변수이다!

사용 방법은
반환 타입 (*변수이름) (매개변수)
int (*cir)(int, int);

함수 포인터로 계산기를 만들어보면서 설명하겠습니다.

코드

#include <iostream>

#pragma warning(disable: 4996)

void plus(int _v1, int _v2)
{
	std::cout << _v1 + _v2 << std::endl;
}

void minus(int _v1, int _v2)
{
	std::cout << _v1 - _v2 << std::endl;
}

void multiple(int _v1, int _v2)
{
	std::cout << _v1 * _v2 << std::endl;
}

void divide(int _v1, int _v2)
{
	std::cout << _v1 / _v2 << std::endl;
}

int main()
{
	void(*cir)(int, int) = nullptr;
	int value = 0;
	char sign = 0;
	int value2 = 0;

	scanf("%d %c %d", &value, &sign, &value2);

	switch (sign)
	{
	case '+' :
		cir = &plus;
		break;
	case '-':
		cir = &minus;
		break;
	case '*':
		cir = &multiple;
		break;
	case '/':
		cir = &divide;
		break;
	default:
		break;
	}
	cir(value,value2);
	return 0;
}

반환 타입 (*변수이름) (매개변수)

void(*cir)(int,int);

cir 함수 포인터는 반환 값 void 매개변수가 int, int가 들어오는 함수를 담을수가 있다.

scanf로 value, sign, value에 값을 받은뒤

switch문으로

사칙 연산에 해당하는 case문으로 이동후

cir 함수 포인터에 각 계산식에 맞는 함수의 포인터를 넣어주면 된다!.

cir 은 plus를 가리킬수도있고!

minus, multiple, divide를 다 가리킬수있다!

C++ 가변 인자 템플릿

꽈이렁 — Tue, 5 May 2020 22:34:36 +0900

https://younggwan.tistory.com/53

C++ 가변인자

정의 매개 변수의 개수가 변할수 있는 인자이다. 예를 들어, printf, scanf 가 가변인자를 사용한 함수이다. 코드로 가변 인자를 사용하면서 설명하겠습니다. 정수를 더하는 가변 인자 함수입니다. 코드 #include..

younggwan.tistory.com

위 글에서 가변 인자에 대해 설명할때는 인자를 int형으로만 받아서 설명을 했다.

그럼 인자의 형태가 여러가지 형태일때는 어떻게 해야할까???

가변 인자 템플릿을 사용하면된다!.

코드를 통해 설명!!

코드

#include <iostream>
void Y_FUNC()
{

}

template <typename T, typename ...Arg>
void Y_FUNC(T _Value, Arg... args)
{
	int count = 0;
	++count;
	std::cout << count << ". " << typeid(T).name() << " : " << _Value << std::endl;
	int tempsize = (int)sizeof...(args);
	std::cout << "남은 변수 : "<< tempsize << std::endl;
	Y_FUNC(args...);
}

int main()
{
	short _s = 2;
	float _f = 3.3f;
	Y_FUNC(1, "YYG", 'C', _s, _f, 11111111111);
	return 0;
}

결과

Y_FUNC()안에 넣어준 인자들이
출력되고 현재 변수의 개수가 출력되고 있는데.
sizeof...() 의 동작은 현재 남은 가변 인자의 개수를 알려줍니다
Y_FUNC()함수 내부를 보면 재귀함수 형태로 인자들을 전달해주는데 재귀의 탈출문이 보이지않습니다

지금 Y_FUNC()는 함수 오버로딩을 이용해 두가지가 있습니다.

1.
...Arg>template ...Arg>
Y_FUNC(Y_FUNC(T _Value, Arg... args)

2.
Y_FUNC()

인자를 받는 함수와 인자를 받지 않는 함수

재귀함수로 가변인자가 계속 값이 들어가면서 1번이 호출되다가 마지막에 더이상 인자가 없을때는
2번 함수가 호출되서 재귀함수가 종료됩니다.

C++ 가변인자

꽈이렁 — Sun, 3 May 2020 20:28:58 +0900

정의

매개 변수의 개수가 변할수 있는 인자이다.
예를 들어, printf, scanf 가 가변인자를 사용한 함수이다.

코드로 가변 인자를 사용하면서 설명하겠습니다.
정수를 더하는 가변 인자 함수입니다.
코드

#include <iostream>

int Y_SUM(int _Count, ...)
{
	int Return_Value = 0;
	va_list va;
	__va_start(&va, _Count);

	for (int i = 0; i < _Count; i++)
	{
		Return_Value += __crt_va_arg(va, int);
	}
	__crt_va_end(va);

	return  Return_Value;
}

int main()
{
	std::cout << Y_SUM(5, 1, 2, 3, 4, 5, 6) << std::endl;
	std::cout << Y_SUM(3, 1, 2) << std::endl;
	std::cout << Y_SUM(5, 2, 4, 6, 8, 10, 12) << std::endl;
	std::cout << Y_SUM(3, 1, 2, 3, 4) << std::endl;
	return 0;
}

결과

설명

가변 인자의 사용 방법을 보자
현재 int Y_SUM(int _Count, ...)라고 선언을 했다.
가변인자는 ...을 사용해서 받고있습니다.

코드를 보면

va_list : 가변인자를 가르키는 포인터

va_start : va_list를 특정 위치로 이동

va_arg : va_list가 가리키는 위치부터 자료형 크기만큼 데이터를 읽어서 반환

va_end : va_list를 NULL로 변경

이렇게 4가지의 가변인자 함수들이있는데

va_list 는 char* 입니다. 매개 변수의 주소 값을 받는 아이입니다.

va_start(&va, _Count)를 하게되면 va에는 첫번째 가변 인자의 주소를 가리키게 되고

va_arg(va, int)를 하게 되면 int의 크기인 4바이트씩 메모리의 주소를 변경하면서 값을 반환한다.

va_end(va)를 하게 되면 va를 NULL로 바꾼다.

Y_SUM(5, 1, 2, 3, 4, 5, 6) 의 출력이 15인 이유는 5번 반복하기때문이다 1 + 2 + 3 + 4 + 5 = 15
가변인자로 6개의 인자를 넣어줘도 반복문으로 5번만 돈다.
Y_SUM(3, 1, 2) 의 출력이 쓰레기값인 이유는 가변 인자의 범위를 넘어가 쓰레기값을 더해주었기때문이다.
Y_SUM(5, 2, 4, 6, 8, 10, 12) 과 Y_SUM(3, 1, 2, 3, 4)의 출력은 첫번째 경우와 같은 경우이다.

증명 해보자

증명

#include <iostream>

int Y_SUM(int _Count, ...)
{
	int Return_Value = 0;

	int* temp_p;
	va_list va;
	__va_start(&va, _Count);
	temp_p = (int*)va;
	for (int i = 0; i < _Count; i++)
	{
		temp_p = (int*)va;
		Return_Value += __crt_va_arg(va, int);
		temp_p = (int*)va;
	}
	__crt_va_end(va);

	return  Return_Value;
}

int main()
{
	std::cout << Y_SUM(5, 1, 2, 3, 4, 5, 6) << std::endl;
	std::cout << Y_SUM(3, 1, 2) << std::endl;
	std::cout << Y_SUM(5, 2, 4, 6, 8, 10, 12) << std::endl;
	std::cout << Y_SUM(3, 1, 2, 3, 4) << std::endl;
	return 0;
}

int* temp_p를 선언해서 va값을 int*로 형변환해서 받아보았다.

va_start() 함수 실행 후
va는 가변 인자중 첫번째인 5를 가리키고있다.

va_arg() 함수 실행 후
va는 다음 인자인 1을 가리키고 있다.

쭉 진행한 후

va_end() 함수 실행 후
va는 NULL이 되었다.

그러면 printf()같은경우 int형만 받는게아니라 char short int double string 여러가지 형태를 받는다.

이럴때는 가변인자 템플릿을 사용해야한다.

가변인자 템플릿은 다음글에서 설명하겠다.

C++ 가상함수테이블(Virtual function table)

꽈이렁 — Sat, 2 May 2020 21:14:04 +0900

정의

부모 클래스의 포인터나 레퍼런스가 자식 클래스 객체를 가리킬 때
자식 클래스의 가상 함수 재정의(Override)에 의해 호출되는 함수가 달라지는 것

다형성의 좋은 예이다.

A클래스에 virtual Func()가 있고 B클래스가 A클래스를 상속 받고 Func()함수를 재정의(Override)했을때
A* a = new B();
a->Func(); 를 하면
컴파일러는 Func()가 A의 Func()를 실행해야하는지 B의 Func()를 실행해야하는 알지를 못합니다.
그럼 어떻게 알아내야 할까??
객체 타입을 런타임중에 알아내는 매커니즘을 RTTI(Run Time Type Information)이라고 하는데
RTTI는 다음 글에 정리하겠습니다.

C++은 가상 함수를 처리하기 위해서 가상 함수를 갖는 클래스 마다 '가상 함수 테이블(Virtual function table)을 생성하는데 가상 함수 테이블은 가상 함수 포인터를 모아둔 배열입니다.

가상함수 포인터(vfptr)는 가상함수를 추가할 경우 객체의 멤버 변수로 가상 함수 테이블을 가리키는 포인터를 멤버 변수로 추가를 시킵니다.

일단 가상 함수 포인터가 실제로 추가되는지 부터 확인하겠습니다.

코드

#include <iostream>

class A
{
private:
	int m_i = 0;
public: 
	void Func()
	{

	}
};

class B : public A
{

};

int main()
{
	A a;
	B b;
	return 0;
}

다음과 같은 코드가 있을때 a와b를 살펴보자.
멤버 변수에 int m_i만 존재한다.

virtual 함수를 추가하면 어떻게 변할까??

#include <iostream>

class A
{
private:
	int m_i = 0;
public: 
	virtual void Func()
	{

	}
};

class B : public A
{

};

int main()
{
	A a;
	B b;
	return 0;
}

가상 함수를 만들자 __vfptr이 추가되었다.
B클래스에서 Func()함수를 재정의 하지 않았기 때문에
a와 b의 __vfptr를 보면 Func()함수 포인터 주소를 0x00ed13a7로 같은 곳을 가리키고있다.

일단 B클래스에서 Func()함수를 재정의 해보겠다.

#include <iostream>

class A
{
private:
	int m_i = 0;
public: 
	virtual void Func()
	{

	}
};

class B : public A
{
public:
	void Func() override
	{

	}
};

int main()
{
	A a;
	B b;
	return 0;
}

B클래스에서 void Func() override로 재정의를 하였다.
override는 암시적으로도 붙기때문에 명시적으로 작성할 필요는 없지만 저는 재정의 했다는걸 한눈에 알 수 있게
작성하는걸 선호하는 편입니다.

자이제 보면 a는 A::Func() 0x009a12ee를 가리키고있고 b는 B::Func() 0x009a1366을 가리키고 있습니다.
재정의 하지 않았을때 B의 Func()는 A의 Func() 포인터를 가리키고 있었지만 재정의하면서 B의 Func()를 가리킵니다.

이렇게 가상 함수테이블에 가상 함수 포인터가 추가되기 때문에 자기의 클래스에 맞는 함수를 찾아갑니다.

그럼 A의 클래스를 100개 만들면 가상함수테이블도 100개 만들어질까???
답은 X입니다.
가상 함수 테이블은 가상 함수가 있는 클래스마다 1개씩만 생성이됩니다.

int main()
{
	A a1;
	A a2;
	A a3;
	A a4;
	B b;
	return 0;
}

메인함수를 위와 같이 수정후 실행하면

가상함수테이블의 주소가 0x00987b34로 다 같은걸 확인할 수 있습니다.

))여담

전 포스트에서 바이트 패딩에 대해 정리했었는데
가장큰 자료형의 크기로 데이터가 정렬이 됬었는데
가상 함수를 사용하면 멤버 변수로 가상함수포인터 __vfptr이 생겼다.
그럼 64비트 환경에서
멤버변수로
int (4byte)
short (2byte)
__vfptr (8byte) 이 있으면 바이트패딩이 이루어질까?
64비트 환경이기에 포인터의 크기는 8바이트
그럼 8(4,2) + 8 = 16이 나와야한다.

바이트 패딩이 가장 큰 크기인 __vfptr의 크기로 된다.

C++ 자료형의 type을 알아내는 방법 typeid()

꽈이렁 — Sat, 2 May 2020 19:55:36 +0900

코드

#include <iostream>
#include <typeinfo>

class A
{
public:

};



int main()
{
	char _c = '0';
	short _s = 0;
	int _i = 0;
	__int64 _i64 = 0;
	const int _ci = 0;

	std::cout << typeid(A).name()<< std::endl;
	std::cout << typeid(_c).name() << std::endl;
	std::cout << typeid(_s).name() << std::endl;
	std::cout << typeid(_i).name() << std::endl;
	std::cout << typeid(_i64).name() << std::endl;
	std::cout << typeid(_ci).name() << std::endl;

	return 0;
}

typeinfo 참조

typeid()를 사용하면 const char* 로 반환받아서 사용할 수 있다.

클래스 같은경우 앞에 class 가 붙어서 출력된다.....

C++ 다형성(Polymorphism)

꽈이렁 — Sat, 2 May 2020 17:36:50 +0900

다형성의 사전적 의미

프로그램 언어의 다형성은 자료형 체계의 성질을 나타낸다.
언어의 각 요소들(상수, 변수, 식, 오브젝트, 메소드 등등) 다양한 자료형에 속하는 것이 허가되는 성질이다.
원래는 생물학에서 유래된 단어라고 하는데, 동일한 종에 속하는 생물이라 할지라도 다양한 변이를 가지는 형상이라고한다.
영어 단어인 Polymorphis은 여러개를 의미하는 그리스어 'Poly'와 모습, 모양을 뜻하는 그리스어 'Morphism'에서 온 단어로 '여러가지 형태'라는 의미이다.

C++ 언어에서의 다형성

가상 함수
부모 클래스와 자식 클래스에 동일한 이름의 함수의 다른 작동

함수 템플릿
동일한 이름의 함수가 다양한 자료형을 처리

함수 오버로드
동일한 이름의 함수가 다른 작동

연산자 오버로드
한가지 연산자가 다양한 작동

함수 이름이 같아도 다른 작업을 하는것을 말한다.

코드

#include <iostream>

class A
{
public:
	virtual void Func()
	{
		std::cout << "A함수" << std::endl << std::endl;
	}
	A()
	{
		std::cout << "A생성" << std::endl << std::endl;
	}
	~A()
	{
		std::cout << "A소멸" << std::endl << std::endl;
	}
};

class B : public A
{
public:
	void Func() override
	{
		std::cout << "B함수" << std::endl << std::endl;
	}
	B()
	{
		std::cout << "B생성" << std::endl << std::endl;
	}
	~B()
	{
		std::cout << "B소멸" << std::endl << std::endl;
	}
};

int main()
{
	A a;
	a.Func();

	B b;
	b.Func();
	return 0;
}

같은 이름의 Func() 함수를 호출했지만
A 함수
B 함수
로 출력되고있다.

#include <iostream>

class A
{
public:
	template <typename T>
	void Func(T _value)
	{
		std::cout << sizeof(T) << std::endl << std::endl;
	}

	A()
	{
		std::cout << "A생성" << std::endl << std::endl;
	}
	~A()
	{
		std::cout << "A소멸" << std::endl << std::endl;
	}
};



int main()
{
	char _c = '0';
	short _s = 0 ;
	int _i = 0 ;
	__int64 _i64= 0;

	A a;
	a.Func(_c);
	a.Func(_s);
	a.Func(_i);
	a.Func(_i64);

	return 0;
}

같은 이름의 Func() 함수를 호출했지만 매개변수로 여러 타입을 받아왔다.

#include <iostream>

class A
{
public:
	void Func()
	{
		std::cout << "A일반 함수" << std::endl << std::endl;
	}

	void Func(char _c)
	{
		std::cout << "A일반 캐릭터" << std::endl << std::endl;
	}

	void Func(short _s)
	{
		std::cout << "A일반 쇼트" << std::endl << std::endl;
	}

	void Func(int _i)
	{
		std::cout << "A일반 인트" << std::endl << std::endl;
	}

	void Func(__int64 _i64)
	{
		std::cout << "A일반 인트64" << std::endl << std::endl;
	}

	A()
	{
		std::cout << "A생성" << std::endl << std::endl;
	}
	~A()
	{
		std::cout << "A소멸" << std::endl << std::endl;
	}
};



int main()
{
	char _c = '0';
	short _s = 0 ;
	int _i = 0 ;
	__int64 _i64= 0;

	A a;
	a.Func();
	a.Func(_c);
	a.Func(_s);
	a.Func(_i);
	a.Func(_i64);

	return 0;
}

같은 이름의 Func() 함수를 호출했지만
매개변수에 타입에 따라 다른 함수가 호출된다.

#include <iostream>

class A
{
public:
	bool operator==(A& _A)
	{
		std::cout << "매개변수 A비교" << std::endl << std::endl;
		return true;
	}
	bool operator==(int _Value)
	{
		std::cout << "매개변수 int" << std::endl << std::endl;
		return true;
	}

	A()
	{
		std::cout << "A생성" << std::endl << std::endl;
	}
	~A()
	{
		std::cout << "A소멸" << std::endl << std::endl;
	}
};



int main()
{
	int _i = 0 ;

	A a;

	A aa;

	bool Result;
	Result = (a == aa);
	Result = (a == _i);

	return 0;
}

같은 == 연산자를 사용했지만
하나는 A클래스를 받고 다른 하나는 int형을 비교했다.
좀 억지스럽게 보여주려고 만든 코드이니 어떻게 작동하는지만 봐주세요.

C++ Lvalue , Rvalue

꽈이렁 — Sat, 4 Apr 2020 16:28:44 +0900

LVALUE,RVALUE

보통 Left Value, Right Value 로 풀어서 씁니다.
그래서 보통 Left Value = Right Value 와 같이
=(대입연산자)를 기준으로 왼쪽 값 Left Value , 오른쪽 값 Right Value 라고 이해할 수 있습니다.
하지만 Lvalue는 = 를 기준으로 왼쪽, 오른쪽 양쪽다 위치할 수 있고, Rvalue는 = 를 기준 오른쪽에만 위치할 수 있습니다.
C++에서는 Lvalue,Rvalue의 L,R을 위치가 아닌 그저 Lvalue,Rvalue 고유명사로 봐주시면 되겠습니다.

Lvalue는 반드시 명시적인 메모리 공간을 가져야 합니다.
값을 대입 받기 때문입니다.
Rvalue는 잠깐? 사용하고 사라지는 임시값입니다.
Lvalue에 값을 전해줄 수만 있으면 됩니다.

코드

#include "pch.h"
#include <iostream>

int main()
{
	int LValue_int = 10;
	return 0;
}

Lvalue = LValue_int
Rvalue = 10
오류가 나지 않는 코드입니다.

#include "pch.h"
#include <iostream>

int main()
{
	int LValue_int = 10;
	20 = LValue_int;
	return 0;
}

Lvalue = LValue_int
Rvalue = 20
Rvalue가 =(대입연산자) 왼쪽에 위치하기에 오류가 나는 코드입니다.

#include "pch.h"
#include <iostream>

int main()
{
	int Temp = 10;
	++Temp = 20;
	Temp++ = 20;
	return 0;
}

그럼 여기서에서 int Temp 는 Lvalue입니다.
그럼 ++Temp, Temp++는 Lvalue일까요 Rvalue일까요

++Temp는 증가된 자신을 return 하기 때문에 Lvalue 입니다.
Temp++는 증가된 복사본을 return 하기 때문이 Rvalue 입니다.
그래서 위 사진과 같이 ++Temp 에는 = 20 이라는 상수를 받을수 있지만.
Temp++은 Rvalue이기 때문에 20이라는 상수를 받을수가 없습니다.

Lvalue와 Rvalue 의 구분이 모호할때는 &연산자를 사용하시면 됩니다. &연산자는 주소연산자 이기 때문에 Lvalue를 요구합니다.

Lvalue 주소를 참조하는 & 연산자가 있다면 Ravlue주소를 참조하는 연산자도 있지않을까

Rvalue Reference 우측값 참조

있다 우측값 참조 &&연산자가 Rvalue를 참조할 수 있는 연산자이다.

C++ 상속, 접근 지정자, 다형성

꽈이렁 — Thu, 2 Apr 2020 15:34:54 +0900

상속

상속은 기존의 클래스를 받아서 기존의 클래스를 포함한 새로운 클래스를 만드는 행위라고 보면된다.

코드

#include "pch.h"
#include <iostream>

class Monster
{
public:
	std::string m_Name;
	int m_HP;
	int m_MP;
    
    	int GetHP()
	{
		return m_HP;
	}

	int GetMP()
	{
		return m_MP;
	}
};

class Fighter : public Monster
{
};

class Archer : public Monster
{
};

class Wizard : public Monster
{
};

int main()
{
	return 0;
}

Monster를 부모클래스
Fighter, Archer, Wizard 를 자식 클래스라고 봤을때
Fighter, Archer, Wizard 는 부모클래스인 Monster의 모든 멤버 변수와 멤버 함수를 물려받는다.

상속을 받는 형식은
class 클래스명 : 상속 접근 지정자 부모클래스명
ex) class Wizard : public Monster이다.

접근 지정자

접근 지정자는 말 그대로 객체의 멤버 변수, 멤버 함수에 접근할 수 있는 권한이다.

public : 어디서든 접근 가능
private : 기반 클래스에서만 접근 가능
protected : 기반 클래스, 파생 클래스에서 접근 가능

상속 접근 지정자

상속 접근 지정자는 부모로 부터 물려받은 멤버 함수와 멤버 객체를 상속 접근 지정자의 형태로 물려받는걸 의미한다.
주의 해야할점은 부모 클래스(기반 클래스) 에서 private로 물려받은 멤버 변수 및 멤버 함수는 private에서 변형되지 않는다.

우선 순위는
1. private
2. protected
3. public

상속 접근 지정자	부모 클래스(기반 클래스)	자식 클래스(파생 클래스)의 상속 형태
public	public	public
	private	private
	protected	protected
private	public	private
	private	private
	protected	private
protected	public	protected
	private	private
	protected	protected

코드

#include "pch.h"
#include <iostream>

class Monster
{
public:
	std::string m_Name;
	int m_HP; //public 외부 접근 가능
private:
	int m_MP; //private 외부 접근 불가능 Monster 클래스에서만 접근 가능
protected:
	int m_DEF; //protected 외부 접근 불가능 Monster 클래스와 Monster클래스의 자식 클래스(파생 클래스)에서만 접근 가능 
public:
	int GetHP()
	{
		return m_HP;
	}

	int GetMP()
	{
		return m_MP;
	}

	virtual void Func()
	{
	}
};

class Fighter : public Monster
{
public:
	void Func() override
	{
		m_HP; //public 외부 접근 가능
		m_MP; //private 외부 접근 불가능 Monster 클래스에서만 접근 가능
		m_DEF; //protected 외부 접근 불가능 Monster 클래스, Fighter클래스, FIghter클래스의 자식 클래스에서 접근 가능
	}
};

class Archer : private Monster
{
public:
	void Func() override
	{
		m_HP; //private 외부 접근 불가능 Monster 클래스 Archer클래스에서 접근 가능
		m_MP; //private 외부 접근 불가능 Monster 클래스에서만 접근 가능
		m_DEF; //private 외부 접근 불가능 Monster 클래스 Archer클래스에서 접근 가능
	}
};

class Wizard : protected Monster
{
public:
	void Func() override
	{
		m_HP; //protected 외부 접근 불가능
		m_MP; //private 외부 접근 불가능 Monster 클래스에서만 접근 가능
		m_DEF; //protcted 외부 접근 불가능 Monster 클래스, Wizard클래스, Wizard클래스의 자식 클래스에서 접근 가능
	}
};

int main()
{
	Monster Temp_Monster;
	Fighter Temp_Fighter;
	Archer Temp_Archer;
	Wizard Temp_Wizard;
	
	Temp_Monster.m_HP; //public 외부에서 접근 가능
	Temp_Monster.m_MP; //priavte 외부에서 접근 불가능
	Temp_Monster.m_DEF; //protected 외부에서 접근 불가능

	Temp_Fighter.m_HP; //public 외부에서 접근 가능
	Temp_Fighter.m_MP; //private 외부에서 접근 불가능
	Temp_Fighter.m_DEF; //potected 외부에서 접근 불가능

	Temp_Archer.m_HP; //private 외부에서 접근 불가능
	Temp_Archer.m_MP; //private 외부에서 접근 불가능
	Temp_Archer.m_DEF; //private 외부에서 접근 불가능

	Temp_Wizard.m_HP; //protected 외부에서 접근 불가능
	Temp_Wizard.m_MP; //private 외부에서 접근 불가능
	Temp_Wizard.m_DEF; //protected 외부에서 접근 불가능

	return 0;
}

Monster의 private 멤버 변수인 m_Mp는 접근이 불가능하다.

외부에서 접근할때를 보면 상속 접근 지정자에 의해 멤버 변수의 접근 제한이 바뀌어
위와 같이 오류가 발생한다.

접근 지정자를 명시하지않았을때 클래스와 구조체의 기본 접근 지정자가 다르다.

class(클래스) : private
struct(구조체) : public

다형성

다형성은 형태는 같지만 행동은 다른 특징이라고 말할 수 있습니다.

C++에서 다형성을 잘 보여주는 예는 Overriding(오버라이딩), Overloading(오버로딩) 으로 말할 수 있다.

코드

#include "pch.h"
#include <iostream>

class Monster
{
public:
	virtual void Attack()
	{
		std::cout << "나는 Monster 공격합니다." << std::endl;
	}

	virtual ~Monster()
	{
	}
};

class Fighter : public Monster
{
public:
	void Attack() override
	{
		std::cout << "나는 Fighter 공격합니다." << std::endl;
	}
};

class Archer : private Monster
{
public:
	void Attack() override
	{
		std::cout << "나는 Archer 공격합니다." << std::endl;
	}
};

class Wizard : protected Monster
{
public:
	void Attack() override
	{
		std::cout << "나는 Wizard 공격합니다." << std::endl;
	}

	void Func()
	{
		std::cout << "나는 일반 Func입니다." << std::endl;
	}
	void Func(int _Value)
	{
		std::cout << "나는 int를 받는 Func입니다." << std::endl;
	}
	void Func(float _Value)
	{
		std::cout << "나는 float를 받는 Func입니다." << std::endl;
	}
};

int main()
{
	Monster Temp_Monster;
	Fighter Temp_Fighter;
	Archer Temp_Archer;
	Wizard Temp_Wizard;
	
	Temp_Monster.Attack();
	Temp_Fighter.Attack();
	Temp_Archer.Attack();
	Temp_Wizard.Attack();

	std::cout << std::endl;
	Temp_Wizard.Func();
	Temp_Wizard.Func(10);
	Temp_Wizard.Func(10.0f);
	return 0;
}

실행 결과

같은 이름의 Attack()을 호출하고
같은 이름의 Func()를 호출했지만 다른 함수를 호출해주고 있는걸 확인할 수 있습니다.

벡터(Vector) 덧셈 뺄셈

꽈이렁 — Tue, 24 Mar 2020 12:26:09 +0900

티스토리 앱에서는 수식이 깨져서 보입니다.!

벡터 덧셈

벡터의 덧셈은 각 성분을 더해주면 됩니다.

게임에서는 벡터의 덧셈을 캐릭터의 이동에 이용할 수 있습니다.

$\mathbf{A} = (A_{x}, A_{y})$

$\mathbf{B} = (B_{x}, B_{y})$

$\mathbf A + \mathbf B = (A_{x} + B_{x}, A_{y} + B_{y})$

예를 들어 A = (3,4) , B = (2,1) 이라고 하면

A + B = (3 + 2, 4 + 1) = (5,5)가 됩니다.

A = 파랑선 B = 주황선 A+B = 노랑선

벡터 뺄셈

벡터의 뺄셈은 각 성분을 빼주면 됩니다.

게임에서는 벡터의 뺄셈을 B캐릭터가 A캐릭터를 바라보는 방향을 찾을 수 있습니다.

$\mathbf{A} = (A_{x}, A_{y})$

$\mathbf{B} = (B_{x}, B_{y})$

$\mathbf A - \mathbf B = (A_{x} - B_{x}, A_{y} - B_{y})$

예를 들어 A = (3,4) , B = (2,1) 이라고 하면

A - B = (3 - 2, 4 - 1) = (1,3)가 됩니다.

A = 파랑선 B = 주황선 A-B = 노랑선

벡터(Vector), 스칼라(Scalar)

꽈이렁 — Wed, 11 Mar 2020 23:18:16 +0900

티스토리 앱에서는 수식이 깨져서 보입니다.!

벡터(Vector), 스칼라(Scalar)

벡터(vector) : 크기와 방향
스칼라(Scalar) : 크기
쉽게 생각하면 속력과 속도로 비교할수있다.
벡터는 속도 스칼라는 속력이라고 했을때
자동차가 100km/h 속력으로 달리고 있다 = 스칼라
자동차가 북쪽 방향으로 100km/h 속도로 달리고 있다 = 벡터
벡터는 크기와 방향을 가지고 스칼라는 크기만 가진 아이이다.

벡터(Vector)

기하학적으로 벡터는 방향을 가진 선분(화살표)로 표현한다.

$\vec{\mathbf{A}}$

벡터의 속성은 '크기', '방향' 이다.
'위치'는 벡터의 속성이 아니다!!!!

다른 위치에 있더라도 동일한 길이와 방향을 가리키는 벡터들은 동일한 벡터이다.

아래 사진은 (2,3) 2차원 벡터

점B에서 A로 향하는 벡터는

$\vec{\mathbf{BA}}$ B(꼬리), A(머리) 쪽이다.

2차원 벡터는

$\mathbf{A} = (A_{x}, A_{y})$

3차원 벡터는

$\mathbf{A} = (A_{x}, A_{y}, A_{z})$

벡터의 크기

벡터의 크기는 방향을 가진 선분의 길이이다.

벡터의 크기를 구하는 식은 아래와 같다.

$|\mathbf{A}| = \sqrt{A_{x}^{2} + A_{y}^{2} + A_{z}^{2} }$

(3,4,5)짜리 3차원 벡터가 있을때 벡터의 크기는
벡터의 크기 = (3*3) + (4*4) + (5*5)
$5\sqrt{2} = \sqrt{25 * 2} = \sqrt{50}$ = 9 + 16 + 25

그럼 이 벡터는 x(3), y(4), z(5)의 방향과 $5\sqrt{2}$ 크기를 가진 벡터이다.

보통 방향 벡터는 단위 벡터로 표현하는데.

단위 벡터란 벡터를 정규화 시킨것이다.

벡터의 정규화

벡터의 크기를 1로 만들어 단위 벡터가 되도록 하는 것이다.

벡터의 크기로 x,y,z 각 성분을 나누어주면 정규화가 된다.

정규화 수식은 $\hat{\mathbf{A}} = \frac{\mathbf{A}}{|\mathbf{A}|}= (\frac{A_{x}}{|\mathbf{A}|}, \frac{A_{y}}{|\mathbf{A}|}, \frac{A_{z}}{|\mathbf{A}|})$ 과 같다.

아까의 3차원 벡터인 (3,4,5)를 정규화 시켜보면

$\hat{\mathbf{A}} = \frac{\mathbf{A}}{5\sqrt{2}} = (\frac{3}{5\sqrt{2}}, \frac{4}{5\sqrt{2}}, \frac{1}{\sqrt{2}})$이 된다.

스칼라

벡터가 크기와 방향이 있다면

스칼라는 크기만 있는 물리량 그저 숫자이다.

벡터와 스칼라 연산

v라는 벡터와 S라는 스칼라값이 있을때
스칼라는 벡터와 곱셈 연산을 통해 벡터의 크기를 조정하는데 사용된다.
$S\mathbf{v} = (Sv_x, Sv_y, Sv_z)$ 모든 성분에 같은 값을 곱해주기에
$S > 0$이면 방향에는 영향이 없지만 $S < 0$ 이면 v벡터의 방향이 뒤집힌다.

만약 S에다가 -1을 대입하면?? v의 역벡터가 된다.
$-\mathbf{v} = (-v_x, -v_y, -v_z)$

C++ 상속시 부모 클래스 소멸자에 virtual(가상 키워드)를 사용해야 하는 이유

꽈이렁 — Wed, 11 Mar 2020 19:02:31 +0900

상속 받은 클래스의 생성자 소멸자 호출 순서

class A
{
}

class B : public A
{
}

class C : public B
{
}

위와 같은 클래스들이 있을때

CChild cc 클래스를 생성하면 생성자 호출 순서는

A -> B -> C

소멸자 호출 순서는

C -> B -> A 이다.

부모 클래스 소멸자에 virtual 사용해야 하는 이유

A* Parent = new C()

부모 클래스의 포인터로 자식 클래스를 호출할때
가상 함수로 정의되지 않은 자식 클래스의 함수를 호출하면 부모 클래스의 멤버 함수가 호출된다.
소멸자도 자식 클래스의 소멸자가아닌 부모클래스의 소멸자가 호출이된다.

가상 함수로 소멸자가 사용되었다면 자식 클래스에서 재정의 될 수 있음을 명시하기 때문에 자식 클래스의 소멸자부터 차례대로 부모 클래스의 소멸자가 호출된다.

디폴트 코드

#include <iostream>

class A
{
public:
	A()
	{
		std::cout << "A생성자" << std::endl;
	}
};

class B : public A
{
public:
	B()
	{
		std::cout << "B생성자" << std::endl;
	}
};

class C : public B
{
public:
	C()
	{
		std::cout << "C생성자" << std::endl;
	}
};

int main()
{
	A* a = static_cast<A*>(new C());
	std::cout << std::endl;
	delete a;
}

결과

생성자 호출 순서

소멸자 코드

#include <iostream>

class A
{
public:
	A()
	{
		std::cout << "A생성자" << std::endl;
	}
	~A()
	{
		std::cout << "A소멸자" << std::endl;
		std::cout << std::endl;
	}
};

class B : public A
{
public:
	B()
	{
		std::cout << "B생성자" << std::endl;
	}
	~B()
	{
		std::cout << "B소멸자" << std::endl;
		std::cout << std::endl;
	}
};

class C : public B
{
public:
	C()
	{
		std::cout << "C생성자" << std::endl;
	}
	~C()
	{
		std::cout << "C소멸자" << std::endl;
		std::cout << std::endl;
	}
};

int main()
{
	A* a = static_cast<A*>(new C());
	std::cout << std::endl;
	delete a;
}

결과

일반 소멸자

Virtual 소멸자 코드

#include <iostream>

class A
{
public:
	A()
	{
		std::cout << "A생성자" << std::endl;
	}
	virtual ~A()
	{
		std::cout << "A소멸자" << std::endl;
		std::cout << std::endl;
	}
};

class B : public A
{
public:
	B()
	{
		std::cout << "B생성자" << std::endl;
	}
	~B()
	{
		std::cout << "B소멸자" << std::endl;
		std::cout << std::endl;
	}
};

class C : public B
{
public:
	C()
	{
		std::cout << "C생성자" << std::endl;
	}
	~C()
	{
		std::cout << "C소멸자" << std::endl;
		std::cout << std::endl;
	}
};

int main()
{
	A* a = static_cast<A*>(new C());
	std::cout << std::endl;
	delete a;
}

결과

자식 부터 차례대로 소멸자 호출.

만약 virtual 키워드가 B클래스에 달린다면?

int main()
{
	A* a = static_cast<A*>(new C());
	B* b = (B*)a;
	C* c = (C*)a;
	std::cout << std::endl;
	delete a;
}

B*, C*를 추가해 a의 주소값을 가져왔다.

위 사진과 같이 a,b,c의 주소값이 동일한걸 확인 할 수 있다.

class A
{
public:
	A()
	{
		std::cout << "A생성자" << std::endl;
	}
	~A()
	{
		std::cout << "A소멸자" << std::endl;
		std::cout << std::endl;
	}
};

class B : public A
{
public:
	B()
	{
		std::cout << "B생성자" << std::endl;
	}
	virtual ~B()
	{
		std::cout << "B소멸자" << std::endl;
		std::cout << std::endl;
	}
};

A클래스 소멸자에 있던 virtual 키워드를 B클래스 소멸자로 옮겨보았다.

b와c의 주소 값이 a와 달라진걸 확인 할 수 있다.

이 상태에서 delete a를하게 되면 에러가 발생한다.

int main()
{
	//A* a = static_cast<A*>(new C());
	A* a = reinterpret_cast<A*>(new C());
	B* b = (B*)a;
	C* c = (C*)a;
	std::cout << std::endl;
	delete a;
}

cast방식을 reinterpret로 cast를 진행하면 에러는 발생하지 않지만
소멸자는 A클래스의 소멸자가 호출이된다.

new C를 하는순간 가상함수 테이블이 생성되는데
A에는 가상함수가 없어서 가상함수 테이블이 생성되지 않고 가상함수 포인터 (vfptr을 가지고 있지 않는다)
또한 MSDN을 살펴보면 static_cast 를 하는순간 포인터의 주소가 변경될 수 있어서 위험하다고 명시하고있다!
그래서 a의 소멸자가 호출 되는 순간 펑!

C++ 자식 클래스(파생)에서 부모 클래스(기초)의 이름이 같은 함수 불러오기

꽈이렁 — Mon, 9 Mar 2020 18:32:58 +0900

코드

#include "pch.h"
#include <iostream>

class Status
{
public:
	void Move()
	{
		printf("Status\n");
	}
};

class Monster
{
public:
	void Move()
	{
		printf("Monster\n");
	}
};

class Slime : public Monster, public Status
{
public:
	void Move()
	{
		printf("Slime\n");
	}
	void move()
	{
		printf("slime\n");
	}
};

int main()
{
	Slime a;
	a.Move();
	a.move();
	a.Monster::Move();
	a.Status::Move();
}

결과

메모리 단편화(Memory Fragmentation)

꽈이렁 — Mon, 9 Mar 2020 15:07:25 +0900

단편화(Fragmentation)

RAM에서 공간이 작은 조각으로 나누어져 사용 가능한 메모리가 충분히 존재하지만 할당이 불가능한 상태이다.

단편화는 내부, 외부 단편화가 있다.

내부 단편화(Internal Frammentation)

메모리를 할당할 때 프로세스의 메모리가 필요한 양보다 더많이 할당되어서 프로세스에서 사용하는 메모리 공간이 낭비 되는 현상이다.

운영체제가 프로세스에 30mb를 할당 해줬을때, 사실상 20mb만 사용하고 있을 경우 내부 단편화가 10mb만큼 발생한다.

30mb의 빈공간에 20mb크기의 프로세스4가 할당되면

10mb의 내부 단편화가 일어나게 됩니다.

외부 단편화(External Fragmentation)

프로세스들의 메모리를 할당하고 난 다음 아주 작은 크기로 남은 조각들이 생겨 사용할 수 없는 작은 메모리 공간들이 생길수 있는데. 이 공간들을 합쳐서 새로운 프로세스가 요구하는 메모리의 크기를 할당할 수 있음에도 불구하고 연속적인 공간이 아니라서 할당을 하지 못하는 경우다.

10mb + 10mb = 20mb의 크기가 남아있지만
20mb의 메모리가 필요한 프로세스4 는 할당 될 수 없다.

문제 해결 방법

문제 해결 방법으로는 페이징(Paging), 세그멘테이션(Segmentation), 메모리 풀(Memory Pool) 이 있다.

페이징(Paging)

가상메모리사용, 외부 단편화 해결, 내부 단편화 존재

보조기억장치를 이용한 가상메모리를 같은 크기의 블록으로 나눈 것을 페이지라고 하고 RAM을 페이지와 같은 크기로 나눈 것을 프레임이라고 할 때,

페이징 기법이란 사용하지 않는 프레임을 페이지에 옮기고, 필요한 메모리를 페이지 단위로 프레임에 옮기는 기법.

페이지와 프레임을 대응시키기 위해 page mapping과정이 필요해서 paging table을 만든다.

페이징 기법을 사용하면 연속적이지 않은 공간도 활용할 수 있기 때문에 외부 단편화 문제를 해결할 수 있다.

대신 페이지 단위에 알맞게 꽉채워 쓰는게 아니므로 내부 단편화 문제는 여전히 있다.

* 페이지 단위를 작게하면 내부 단편화 문제도 해결할 수 있겠지만 대신 page mapping 과정이 많아지므로 오히려 효율이 떨어질 수 있다.

세그멘테이션(Segmentation)

가상메모리사용, 외부 단편화 존재, 내부 단편화 해결

페이징기법에서 가상메모리를 같은 크기의 단위로 분할했지만 세그멘테이션기법에서는 가상메모리를 서로 크기가 다른 논리적 단위인 세그먼트로 분할해서 메모리를 할당하여 실제 메모리 주소로 변환을 하게 된다.

각 세그먼트는 연속적인 공간에 저장되어 있다.

세그먼트들의 크기가 다르기 때문에 미리 분할해 둘 수 없고 메모리에 적재될 때 빈 공간을 찾아 할당하는 기법이다.

마찬가지로 mapping을 위해 세그먼트 테이블이 필요하다.

(각 세그먼트 항목별 세그먼트 시작주소와 세그먼트의 길이 정보를 가지고 있음)

프로세스가 필요한 메모리 만큼 할당해주기 때문에 내부단편화는 일어나지 않으나 여전히 중간에 프로세스가 메모리를 해제하면 생기는 구멍, 즉 외부 단편화 문제는 여전히 존재한다.

메모리 풀(Memory Pool)

가상메모리사용, 외부 단편화 해결, 내부 단편화 해결

필요한 메모리 공간을 필요한 크기, 개수 만큼 사용자가 직접 지정하여 미리 할당받아 놓고 필요할 때마다 사용하고 반납하는 기법

메모리 풀 없이 동적할당과 해제를 반복하면 메모리의 랜덤한(실제로는 알고리즘에 의한) 위치에 할당과 해제가 반복되면서 단편화를 일으킬 수 있겠지만 미리 공간을 할당해놓고 가져다 쓰고 반납하기 때문에 할당과 해제로 인한 외부 단편화가 발생하지 않는다.

또한 필요한 크기만큼 할당을 해놓기 때문에 내부 단편화 또한 생기지 않는다.

하지만 메모리 단편화로 인한 메모리 낭비량보다 메모리 풀을 만들었지만 쓰지 않았을 때 메모리 양이 커질 경우 사용하지 않아야 한다.

메모리의 할당, 해제가 잦은 경우에 메모리 풀을 쓰면 효과적이다.

미리 할당해놓고 사용하지 않는 순간에도 계속 할당해놓으므로 메모리 누수가 있는 방식이다.

메모리 풀(Memory Pool) 구현 방법

- 큰 메모리 블록(페이지)을 힙으로 부터 할당
- 할당 받은 페이지를 각 객체의 크기의 블록으로 나눔
- 각 객체를 위한 블록을 순차적으로 링크
- 이 때 현 시점에서 할당할 블록을 특정 포인터가 가리키게 함
- 메모리 요청이 생기면 현재 헤더 포인터가 가리키는 블록을 돌려준다.
- 할당이 일어난 후 헤더 포인터는 할당 직전에 가리키던 블록이 가리키던 블록을 가리킨다.
- 사용되던 메모리가 해제되어 메모리 풀로 돌아올 경우 헤더 포인터는 그 블록을 가리키고 방금 전까지 헤더 포인터가 가리키던 블록을 돌아온 블록의 다음 포인터가 가리키게 한다.

출처 : https://jeong-pro.tistory.com/91

C++ 콘스트(const)

꽈이렁 — Mon, 9 Mar 2020 04:26:55 +0900

콘스트(const)

변수를 상수화 하기 위해 사용된다. 쓰이는 위치에 따라서 용도가 달라진다.

* 앞 뒤로 구별하면 된다.

const * 상수 데이터

#include "pch.h"
#include <iostream>

int main()
{
	int TempValue = 10;
	int TempValue2 = 20;

	const int* TempPoint1 = &TempValue;
	int const* TempPoint2 = &TempValue;

	TempPoint1 = &TempValue2;
	*TempPoint1 = 30;

	TempPoint2 = &TempValue2;
	*TempPoint2 = 30;
}

포인터주소의 값이 불변이 된다.

	수정
포인터 변수	가능
포인터 주소의 값	불가능

주소의 값을 변경하려면 에러가 뜬다.
*앞에 const가 위치하면 되기에
const int *
int const *
같다.

* const 상수 포인터

#include "pch.h"
#include <iostream>

int main()
{
	int TempValue = 10;
	int TempValue2 = 20;

	int* const TempPoint1 = &TempValue;

	TempPoint1 = &TempValue2;
	*TempPoint1 = 30;
}

포인터 변수가 불변이 된다.

	수정
포인터 변수	불가능
포인터 주소의 값	가능

포인터 변수를 변경하려고 하면 에러가 발생한다.

const * const

포인터 변수, 포인터 주소의 값 둘다 불변이 된다.

#include "pch.h"
#include <iostream>

int main()
{
	int TempValue = 10;
	int TempValue2 = 20;

	const int* const TempPoint1 = &TempValue;

	TempPoint1 = &TempValue2;
	*TempPoint1 = 30;
}

포인터 변수, 포인터 주소의 값 둘다 변경하려고하면 에러가 발생한다.

	수정
포인터 변수	불가능
포인터 주소의 값	불가능

C++ 바이트 패딩(Byte Padding)

꽈이렁 — Mon, 9 Mar 2020 02:01:09 +0900

바이트 패딩(Byte Padding)

클래스(구조체)에 패딩 바이트를 추가하여 CPU 접근을 더 용이하게 해주는 기법

코드

#include "pch.h"
#include <iostream>

class TestClass
{
	char m_Temp_Char[2];
	int m_Temp_Int;
	short m_Temp_Short1;
	short m_Temp_Short2;
	short m_Temp_Short3;
};

int main()
{
	TestClass TempTestClass;
	int Size_1 = sizeof(TempTestClass);
	std::cout << Size_1 << std::endl;
}

TestClass의 크기는?

1. char m_ char m_Temp_Char[2];
2. int m_Temp_Int;
3. short m_Temp_Short1;
4. short m_Temp_Short2;
5. short m_Temp_Short3;

1 = 2byte
2 = 4byte
3 = 2byte
4 = 2byte
5 = 2byte

2 + 4 + 2 + 2 + 2 = 12byte라고 생각할 수 도 있다.

하지만 답은

바이트 패딩이란 한번 연산에 하나의 값이 들어가게끔 패딩 바이트를 추가해주는건데.

1. char m_ char m_Temp_Char[2];
2. int m_Temp_Int;
3. short m_Temp_Short1;
4. short m_Temp_Short2;
5. short m_Temp_Short3;

제일 큰 단위인 int의 크기를 따라가게된다

크기가 12바이트 라고 생각했을때의 메모리 구조는

바이트 패딩이 일어난 TestClass의 메모리구조는 아래와 같이 구성됩니다.

가장 큰 크기인 int형 4바이트 크기에 맞춰 위와 같이 패딩 바이트를 추가하여 메모리는 더 사용하나 속도는 빨라집니다.

바이트 패딩을 고려한 구조

#include "pch.h"
#include <iostream>

class TestClass
{
	char m_Temp_Char[2];
    	short m_Temp_Short1;
	short m_Temp_Short2;
	short m_Temp_Short3;
	int m_Temp_Int;
};

int main()
{
	TestClass TempTestClass;
	int Size_1 = sizeof(TempTestClass);
	std::cout << Size_1 << std::endl;
}

1. char m_ char m_Temp_Char[2];
2. short m_Temp_Short1;
3. short m_Temp_Short2;
4. short m_Temp_Short3;
5. int m_Temp_Int;

1 = 2byte
2 = 2byte
3 = 2byte
4 = 2byte
5 = 4byte

4byte씩 딱 떨어지기에 Class의 크기는 12byte로 4byte 줄어들었습니다.

C++ #define 매크로 상수, 매크로 함수

꽈이렁 — Sun, 8 Mar 2020 21:33:24 +0900

#define

매크로를 정의할 때 앞에 써주는 키워드이다
여기서 매크로는 프로그램 내에서 컴파일러가 매크로를 만났을 때, 대체할 문자열이다
매크로는 컴파일 과정인 전처리기 -> 컴파일러 -> 어셈블러 -> 링커 중
전처리기 단계에서 #define으로 정의된 기호 상수 등을 확장 문자열로 변환시키는 동작을 한다.

형식

#define NAME = "YOUNGWAN" //매크로 상수
#define PI = 3.14f //매크로 상수
#define func(_a, _b) ((_a) < (_b) ? (_a) : (_b)) //매크로 함수

매크로 상수

미리 정의한 매크로 상수명이 사용되면 -> 매크로 확장 문자열로 치환을 한다.

매크로 함수

미리 정의한 매크로 함수명이 사용되면 -> 전달인자의 형태를 고려해서 치환하는 동작을 한다.

장단점?

프로그램 가독성이 좋아진다
유지보수가 쉬워진다.
변수를 사용하는 것 보다 빠르다고 하지만
#define 보다는 const, enum, inline을 사용하는 것이 좋다고한다.
왜냐하면 위에적은것처럼 #define은 변수가 아닌 단순히 치환되는 형태이기 때문이다.

주의사항

#include "pch.h"
#include <iostream>

#define func(_a, _b) ((_a) < (_b) ? (_a) : (_b))

int main()
{
	int temp = 1;
	int Result = func(1, temp++);
    
    ////////이때
    Result;
    temp;
    //두개의 값은?
}

증감 연산자를 사용할때 주의를 해야한다.
Result = 2
temp = 3
이라는 결과가 나올텐데
이것은 temp++이 치환되면서 2가되고 조건문에서 한번더 사용되면서 증감 연산자가 두번 행해진다.

또 괄호의 유무에도 주의 사항이 있다.

#include "pch.h"
#include <iostream>

#define PLUS1 1 + 2
#define PLUS2 (1 + 2)

int main()
{
	int temp1 = PLUS1 * 5;
	int temp2 = PLUS2 * 5;
}

temp1의 경우
1 + 2 * 5 = 11
temp2의 경우
(1 + 2) * 5 = 15
위오 같은 형식으로 작동한다.

C++ 얕은복사(Shallow Copy) 깊은복사(Deep Copy)

꽈이렁 — Wed, 4 Mar 2020 03:01:39 +0900

깊은 복사와 얕은 복사

객체는 다른 객체를 참조할 수 있는데 이럴 경우에 깊은 복사인가, 얕은 복사인가에 따라 결과값이 달라질 수 있으니 주의해야합니다.

복사를 한다는 것은 기존 객체와 같은 값을 가진 새로운 객체로 만든다는 것

객체들은 멤버를 가지고 있고 그 멤버들은 값일 수도 있고 참조 형식일 수도 있습니다.

- 바로 이 객체들이 가진 값 형식과 참조 형식의 복제 방식에 따라 얕은 복사와 깊은 복사의 개념이 나누어지게 됩니다.

얕은 복사(Shallow Copy)

얕은 복사는 객체가 가진 멤버들의 값을 새로운 객체로 복사하는데 만약 객체가 참조타입의 멤버를 가지고 있다면 참조값만 복사가 됩니다.

얕은 복사 코드

#include <iostream>
#include <memory>

class TestClass
{
public:
	char* m_Name;
	int m_Age;

	void PrintInfo()
	{
		std::cout << "Name : " << m_Name << std::endl;
		std::cout << "Age  : " << m_Age << std::endl;
	}

	TestClass()
	{

	}
	~TestClass()
	{
		std::cout << "소멸자 호출" << std::endl;
	}
};

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
	TestClass A_Class;
	A_Class.m_Name = new char[3];
	strcpy_s(A_Class.m_Name, 3, "YG");
	A_Class.m_Age = 10;

	A_Class.PrintInfo();

	std::cout << "B클래스 = A클래스 하고 A클래스 정보를 바꾸면?" << std::endl;

	TestClass B_Class = A_Class;

	strcpy_s(A_Class.m_Name, 3, "YJ");
	A_Class.m_Age = 20;

	A_Class.PrintInfo();
	B_Class.PrintInfo();
}

결과

A클래스의 이름을 YJ 나이를 20으로 변경했을때
A클래스를 얕은복사한 B클래스의 이름까지 바뀐걸 볼수있습니다.
기본 복사 생성자를 이용했으니 이번엔 얕은 복사 생성자 코드.

#include <iostream>
#include <memory>

class TestClass
{
public:
	char* m_Name;
	int m_Age;

	void PrintInfo()
	{
		std::cout << "Name : " << m_Name << std::endl;
		std::cout << "Age  : " << m_Age << std::endl;
	}

	TestClass()
	{
		std::cout << "생성자 호출" << std::endl;
	}

//////////////////////얕은복사
	TestClass(const TestClass& _Value)
	{
		std::cout << "복사 생성자 호출" << std::endl;
		m_Age = _Value.m_Age;
		m_Name = _Value.m_Name;
	}

	~TestClass()
	{
		std::cout << "소멸자 호출" << std::endl;
	}
};

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
	TestClass A_Class;
	A_Class.m_Name = new char[3];
	strcpy_s(A_Class.m_Name, 3, "YG");
	A_Class.m_Age = 10;

	A_Class.PrintInfo();

	TestClass B_Class = A_Class;

	std::cout << "B클래스 = A클래스 하고 A클래스 정보를 바꾸면?" << std::endl;


	strcpy_s(A_Class.m_Name, 3, "YJ");
	A_Class.m_Age = 20;

	A_Class.PrintInfo();
	B_Class.PrintInfo();
}

빌드시 복사 생성자에 중단점이 걸린걸 확인 할 수 있습니다.

디폴트 복사 생성자는 얕은 복사를 사용하는걸로 확인됩니다.
이런 방식에 문제점이 멀까요

	TestClass A_Class;
	A_Class.m_Name = new char[3];
	strcpy_s(A_Class.m_Name, 3, "YG");

new char[3] 동적 할당을 하고있어서 릭이 체크되고 있는데
TestClass는 A_Class, B_Class 두개를 만들었는데 3 bytes long. 만큼만 체크가 되고있습니다.

소멸자에서 릭을 delete 해보겠습니다.

	~TestClass()
	{
		std::cout << "소멸자 호출" << std::endl;
		delete[] m_Name;
	}

펑 하고 터졌습니다
TestClass는 A_Class, B_Class 두개를 만들었는데 얕은 복사를 해서 메모리 참조를 하고있으니
삭제한 메모리를 한번더 삭제하려고 하니까 터지고있습니다. 그럼 깊은 복사 생성자를 만들어 보겠습니다.

깊은 복사(Deep Copy)

깊은 복사 또는 전체 복사.
얕은 복사와는 달리 객체가 가진 모든 멤버(값과 참조형식 모두)를 복사하는 것을 말합니다.
객체가 참조 타입의 멤버를 포함할 경우 참조값의 복사가 아닌 참조된 객체 자체가 복사되는 것을 깊은 복사라 합니다.

깊은 복사 코드

#include <iostream>
#include <memory>

class TestClass
{
public:
	char* m_Name;
	int m_Age;

	void PrintInfo()
	{
		std::cout << "Name : " << m_Name << std::endl;
		std::cout << "Age  : " << m_Age << std::endl;
	}

	TestClass()
	{
		std::cout << "생성자 호출" << std::endl;
	}

	/////////////////깊은 복사로 바꿈
	TestClass(const TestClass& _Value)
	{
		std::cout << "복사 생성자 호출" << std::endl;
		m_Age = _Value.m_Age;
		m_Name = new char[strlen(_Value.m_Name) + 1];
		strcpy_s(m_Name, strlen(_Value.m_Name) + 1, _Value.m_Name);
	}

	~TestClass()
	{
		std::cout << "소멸자 호출" << std::endl;
		delete[] m_Name;
	}
};

int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
	TestClass A_Class;
	A_Class.m_Name = new char[3];
	strcpy_s(A_Class.m_Name, 3, "YG");
	A_Class.m_Age = 10;

	A_Class.PrintInfo();

	TestClass B_Class = A_Class;

	std::cout << "B클래스 = A클래스 하고 A클래스 정보를 바꾸면?" << std::endl;


	strcpy_s(A_Class.m_Name, 3, "YJ");
	A_Class.m_Age = 20;

	A_Class.PrintInfo();
	B_Class.PrintInfo();
}

결과

A클래스의 이름만 수정되고!
B클래스의 이름은 그대로!
릭도 남지않고 깔끔하게 프로그램이 종료됬습니다!.

std::weak_ptr

꽈이렁 — Tue, 3 Mar 2020 18:07:27 +0900

https://younggwan.tistory.com/36

윗 글에서 std::shared_ptr 의 정의와 문제점에대한 정리를 했는데.
std::shared_ptr의 문제점이 였던 순환 참조 문제를 해결할 수 있는 std::weak_ptr을 정리해 봅시다.

정의

weak_ptr은 하나 이상의 shared_ptr 인스턴스가 소유하는 객체에 대한 접근을 제공하지만, 소유자의 수에는 포함되지 않는 스마트 포인터입니다.

shared_ptr은 참조 횟수(reference count)를 기반으로 동작하는 스마트 포인터입니다.

만약 서로가 상대방을 가리키는 shared_ptr를 가지고 있다면, 참조 횟수는 절대 0이 되지 않으므로 메모리는 영원히 해제되지 않습니다.

이렇게 서로가 상대방을 참조하고 있는 상황을 순환 참조(circular reference)라고 합니다.

weak_ptr은 바로 이러한 shared_ptr 인스턴스 사이의 순환 참조를 제거하기 위해서 사용됩니다.

멤버 함수

reset : 관리 객체의 소유권을 공개 합니다.
swap : 관리 객체를 교환합니다.
use_count : shared_ptr개체를 관리하는 개체 수를 반환합니다.
expired : 참조된 객체가 삭제되었는지 확인합니다.
lock : shared_ptr로 변환 해서 참조할 수 있게 합니다.(변환이 맞는지는 모르겠습니다)
owner_before : 약한 포인터의 소유자 기반 순서를 제공합니다.

사용 예제

#include <iostream>

#include <memory>

class TestClass

{

public:

std::string name;

std::weak_ptr<TestClass> m_Other_Class;

void TestFunc()

{

std::cout << "hahaha" << std::endl;

}

void Set_Class(std::weak_ptr<TestClass> _Value)

{

m_Other_Class = _Value;

}

void Access_Other_Class()

{

std::shared_ptr<TestClass> convert_weak_ptr = m_Other_Class.lock();

if (convert_weak_ptr)

{

std::cout << this->name.c_str() << " 접근 성공 -> " << convert_weak_ptr->name.c_str() <<std::endl;

}

else

{

std::cout << "접근 실패" << std::endl;

}

TestClass(std::string _name) : name(_name)

{

std::cout << this->name.c_str() <<" 생성자 호출" << std::endl;

}

~TestClass()

{

std::cout << this->name.c_str() << " 소멸자 호출" << std::endl;

}

};

int main()

{

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

std::shared_ptr<TestClass> T_A = std::make_shared<TestClass>("A클래스");

std::shared_ptr<TestClass> T_B = std::make_shared<TestClass>("B클래스");

T_A->Set_Class(T_B);

T_B->Set_Class(T_A);

T_A->Access_Other_Class();

T_B->Access_Other_Class();

T_B.reset();

T_A->Access_Other_Class();

}

결과

A클래스 생성자 호출
B클래스 생성자 호출
A클래스 접근 성공 -> B클래스
B클래스 접근 성공 -> A클래스
B클래스 소멸자 호출
접근 실패
A클래스 소멸자 호출

순환 참조의 소멸자 호출이 없어서 릭이 남던 문제가 없어지고 정상적으로 작동을 한다.

std::shared_ptr 정의 및 문제점

꽈이렁 — Mon, 2 Mar 2020 20:55:06 +0900

std::shared_ptr은 refrerence-counting smart pointer 중 하나.
std::shared_ptr은 포인터를 통해 객체의 공유 소유권을 유지하는 스마트 포인터이다.
스마트 포인터의 기본적인 특성인 자신이 소멸될 때 가리키고 있는 대상에 대해 자동으로 delete 해줘 메모리 누수 걱정은 없게 작성이 되어 있다.
여러 shared_ptr 객체가 동일한 객체를 소유 할 수 있고, 객체가 삭제되고 다음 중 하나가 발생하면 메모리가 해재된다.
-마지막으로 남아있는 shared_ptr을 소유하고 있는 객체가 삭제된다.
-마지막으로 남아있는 shared_ptr을 소유하고 있는 객체가 다른 포인터에 의해 operator= 또는 reset()으로 할당된 경우 객체가 파괴된다.
shared_ptr은 다른 객체에 대한 포인터를 저장하는 동안 객체의 소유권을 공유할 수 있으며 이 기능은 개체를 소유하는 동안 개체를 가리키는 데 사용할 수 있다. 저장된 포인터는 get(), 역참조와 비교 연산자에 의해 액세스 된 포인터이다.
사용된 카운터가 0이 되면 관리되는 포인터는 deleter에 전달된다.

멤버 함수

get : 저장된 포인터를 반환한다.
operator*, operator-> : 저장된 포인터를 역참조한다.
operator[] : 저장된 배열에 대해 인덱스로 접근할 수 있도록 한다.
use_count : 동일하게 관리되는 객체를 참조하는 shared_ptr의 수를 반환한다.
unique : 관리되는 객체가 오직 현재 shared_ptr 인스터스에서만 관리되는지 확인한다.
operator bool : 저장된 포인터가 null이 아닌지 체크한다.
owner_before : 공유 포인터의 소유자 기반 순서를 제공한다.

사용 예제

#include <iostream>
#include <memory>

class TestClass
{
public:
void TestFunc()
{
std::cout << "hahaha" << std::endl;
}

public:
TestClass()
{
std::cout << "생성자 호출" << std::endl;
}
~TestClass()
{
std::cout << "소멸자 호출" << std::endl;
}
};

int main()
{
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
new int;
std::shared_ptr<TestClass> TempClass(new TestClass());
TempClass->TestFunc();
}

결과

생성자 호출
hahaha
소멸자 호출

릭 검출

생성자 호출 -> hahaha -> 소멸자 호출이 출력되고
동적할당을 new int, new TestClass() 두가지를 했지만
new TestClass()는 delete삭제가 되고 new int는 삭제가 되지 않아 릭이 남았다.
std::shared_ptr의 래퍼런스 카운트가 0이 되면서 TestClass()를 삭제했기 때문이다.
동적 메모리관리를 이렇게 편하게 할 수 가 있는데. 문제점은 무엇이 있을까?

문제점

shared_ptr은 래퍼런스 카운트가 0 이되면 가리키는 객체를 메모리에서 해제 시킨다고 했는데.
서로를 순환참조하는 shared_ptr이 있다면 어떻게 될까요
객체 A와 객체 B가 있다고 가정을하고 이객체들은 shared_ptr을 하나 씩 가지고 있을때
A는 B의, B는 A의 shared_ptr을 가리키고 있다면
A가 삭제가 되기 위해서는 A를 가리키고있는 shared_ptr의 래퍼런스 카운트가 0이 되어야하는데
그럼 B가 파괴가 되어야합니다. 근데 B가 파괴가 되려면 A가 파괴가 되어야하고 A가 파괴되려면 B가 파괴되어야하고.....
이러지도 저러지도 못하는 상황이 됩니다.

#include <iostream>
#include <memory>

class TestClass
{
public:
std::shared_ptr<TestClass> m_Other_Class;
void TestFunc()
{
std::cout << "hahaha" << std::endl;
}

void Set_Class(std::shared_ptr<TestClass> _Value)
{
m_Other_Class = _Value;
}

TestClass()
{
std::cout << "생성자 호출" << std::endl;
}
~TestClass()
{
std::cout << "소멸자 호출" << std::endl;
}
};

int main()
{
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
std::shared_ptr<TestClass> T_A = std::make_shared<TestClass>();
std::shared_ptr<TestClass> T_B = std::make_shared<TestClass>();

T_A->Set_Class(T_B);
T_B->Set_Class(T_A);
}

문제 코드 결과

생성자 호출
생성자 호출

릭 검출

소멸자는 호출 되지 않고 릭도 남았습니다.

해결방안

shared_ptr자체에 내재되어 있는 문제이기 때문에 shared_ptr로는 해결을 할 수 없습니다.
순환 참조 문제를 해결하기 위해서는 std::weak_ptr을 사용하면 됩니다.
std::weak_ptr에 대한 정리는 다음글에서 마무리하겠습니다.

참고

https://hojak99.tistory.com/270

C++ new, malloc

꽈이렁 — Mon, 2 Mar 2020 18:02:13 +0900

malloc : 라이브러리에서 제공하는 메모리 할당 함수, free(변수명) 으로 할당 내용을 해제한다.

- 형태 : void *malloc(size_t size), 반환형 : *void 메모리공간

+ 예 : int a = (int*)malloc(50 * sizeof(int));

- int형의 자료가 50개가 들어갈 공간을 확보, a[0~49]의 인덱스로 접근가능

- 프로그램 실행 중에 메모리를 할당받는 동적 메모리 할당 함수

new : 변수나 함수 객체의 생성자를 자동으로 호출하는 연산자, delete로 해제한다.

malloc	new
라이브러리가 제공하는 함수	프로그래밍 언어가 제공하는 연산자 - 오버로딩 가능
필요한 메모리 양을 바이트 단위로 지정하고 void*를 리턴 - sizeof 연산자와 캐스트 연산자의 도움이 필요하다. - void를 리턴 다양한 형식(char, int 등)에 적용되어야 한다.	타입을 지정하고 해당 타입의 포인터를 리턴한다. - 할당한 타입과 같은 타입의 포인터 변수로 대입만 받으면 된다.
메모리 할당이 목적, 초기값 할당 불가 - 다른 예로 calloc 함수는 malloc 처럼 메모리 할당을 하는 점에선 같지만 모든 공간을 0으로 초기화한다. - calloc도 0으로 초기화 할 뿐이지 원하는 변수로 초기화는 불가	할당과 초기화를 동시에 진행 가능 - int a = new int(123); - int a = new int(); a = 123; + 같은 결과가 나온다.
오로지 메모리 공간 만을 할당 - 생성자를 호출하지 않음	생성자를 자동으로 호출 - 생성자 : 객체를 초기화하는 함수
할당된 메모리는 크기 변경이 가능하다. - realloc으로 재할당 가능	재할당이 불가능하다. - 새로운 변수를 만들고 그 안에 원래 변수를 만들어 대체하는 식으로 재할당해야한다. - 재할당 할 때마다 메모리 번지가 바뀐다.
객체가 아니고 빈번하게 재할당을 한다면 malloc/free	객체를 할당할 때에는 반드시 new / delete - delete는 소멸자라고 불리우는 함수가 호출되어 삭제된다.

출처

https://wonjayk.tistory.com/252?category=535160

마인파이터

꽈이렁 — Mon, 2 Mar 2020 17:37:31 +0900

마인크래프트 같은 복셀 맵 기반의 8인 온라인 FPS게임입니다.

자체엔진 2D포트폴리오 스타듀밸리 모작

꽈이렁 — Mon, 2 Mar 2020 17:35:37 +0900

자체엔진 2D포트폴리오 스타듀밸리 모작입니다.

DirectX11 자체엔진 3D포트폴리오 블레이드&소울 모작

꽈이렁 — Mon, 2 Mar 2020 17:32:32 +0900

DirectX11 자체엔진 3D포트폴리오 블레이드&소울 모작입니다.

DirectX11 자체엔진 2D포트폴리오 위자드 오브 레전드 모작

꽈이렁 — Mon, 2 Mar 2020 17:29:28 +0900

DirectX11 자체엔진 2D포트폴리오 위자드 오브 레전드 모작입니다!

오버로딩 (Overloading)

꽈이렁 — Mon, 2 Mar 2020 17:16:02 +0900

오버로딩 - 함수 중복 정의

오버로딩은 같은 이름의 함수에 매개변수를 다르게 사용하여 매개 변수에 따라 다른 함수처럼 사용할 수 있습니다.

특징
1. 함수 이름이 같아야한다.
2. 리턴형이 같아도 되고 달라도 된다.
3. 파라미터 개수가 달라야한다.
4. 파라미터 개수가 같을경우 자료형이 달라야한다.

예제 소스

class TestClass
{
public:
void OverloadingTest(int _Value)
{
std::cout << "int : " << _Value << std::endl;
}

void OverloadingTest(float _Value)
{
std::cout << "float : " << _Value << std::endl;
}

void OverloadingTest(std::string _Value)
{
std::cout << "string : " << _Value.c_str() << std::endl;
}
};

int main()
{
TestClass Test;
Test.OverloadingTest(10);
Test.OverloadingTest(3.14f);
Test.OverloadingTest("overloading");
}

결과
int : 10
float : 3.14
string : overloading

오버라이딩 (Overriding)

꽈이렁 — Mon, 2 Mar 2020 17:01:19 +0900

오버라이딩 - 함수 재정의

부모클래스의 함수를 사용하지 않고 자식 클래스만의 기능으로 사용하고 싶을 때
부모클래스 함수와 같은 이름, 매개변수로 재정의 해서 사용하는것이다.

특징
1. 함수 이름이 같아야한다.
2. 함수 파라미터 개수, 파라미터의 자료형이 같아야 한다.
3. 오버라이드 하고자 하는 함수가 상위 클래스에 있어야한다.
4. 함수 리턴형이 같아야 한다.

예제 소스

class ParentClass //부모클래스
{
public:
virtual int OverrideTest(int _Value1, int _Value2) //부모클래스 함수에 virtual 키워드를 붙여주어야한다.
{
return _Value1 + _Value2;
}
};

class ChildClass : public ParentClass
{
public:
int OverrideTest(int _Value1, int _Value2) override
//자식클래스 함수에는 override가 암시적으로 붙지만 명시적으로 작성해주는것이 좋다.
{
return _Value1 - _Value2;
}
};

int main()
{
ParentClass Parent;
ChildClass Child;

int Result_Parent;
int Result_Child;

Result_Parent = Parent.OverrideTest(10, 20);
Result_Child = Child.OverrideTest(10, 20);

std::cout << Result_Parent << std::endl;
std::cout << Result_Child << std::endl;
}

결과
30
-10

C++ Map [STL]

꽈이렁 — Sat, 23 Feb 2019 20:06:05 +0900

맵 기본 함수

기본형태

map<key,value> : key와 value를 pair 형태로 선언합니다.

iterator(반복자)

begin() : beginning iterator를 반환

end() : end iterator를 반환

추가 및 삭제

insert( make_pair(key,value) ) : 맵에 원소를 pair 형태로 추가

erase(key) : 맵에서 key(키값)에 해당하는 원소 삭제

clear() : 맵의 원소들 모두 삭제

조회

find(key) : key(키값)에 해당하는 iterator를 반환

count(key) : key(키값)에 해당하는 원소들(value들)의 개수를 반환

기타

empty() : 맵이 비어있으면 true 아니면 false를 반환

size() : 맵 원소들의 수를 반환

구현 코드

#include <iostream>

#include <map>

#include <string>

using namespace std;

int main(){

// map

// <string, int> => <key, value>

map< string, int > m;

// insert(key,value)

m.insert(make_pair("a", 1));

m.insert(make_pair("b", 2));

m.insert(make_pair("c", 3));

m.insert(make_pair("d", 4));

m.insert(make_pair("e", 5));

m["f"] = 6; // also possible

// erase(key)

m.erase("d");

m.erase("e");

m.erase(m.find("f")); // also possible

// empty(), size()

if(!m.empty()) cout << "m size : " << m.size() << '\n';

// find(key)

cout << "a : " << m.find("a")->second << '\n';

cout << "b : " << m.find("b")->second << '\n';

// count(key)

cout << "a count : " << m.count("a") << '\n';

cout << "b count : " << m.count("b") << '\n';

// begin(), end()

cout << "traverse" << '\n';

// map< string, int >::iterator it; also possible

for(auto it = m.begin(); it != m.end(); it++){

cout << "key : " << it->first << " " << "value : " << it->second << '\n';

}

return 0;

}

C++ 캐스트(static_cast / const_cast / dynamic_cast / reinterpret_cast)

꽈이렁 — Thu, 31 Jan 2019 16:00:55 +0900

c++의 명시적 캐스트 연사자들이다.

1. const_cast

클래스에서 const, volatile 및 __unaligned 특성을 제거합니다.

void main()

{

char str[] = "String";

const char *c1=str;

char *c2;

c2 = const_cast<char *>(c1);

c2[0] = 'a';

printf("%s\n", c2);

}

결과 : atring

2. static_cast

명시적 형 변환을 위한 캐스트 연산자.

class super

{

};

class sub : public super

{

};

int main()

{

sub* ss = static_cast<sub*>(new super());

}

// sub* ss = new super();

// '초기화 중' : super *'에서 'main::sub *'(으) 로 변환할수 없습니다.

// 기본 형식에서 파생 형식으로 캐스팅하려면 dynamic_cast 또는 static_cast가 필요합니다.

3. dynamic_cast

포인터나 레퍼런스를 기본 클래스 -> 파생 클래스로의 다운 캐스팅과,

다중 상속에서 클래스 간의 안전한 타입 캐스팅에 사용된다.

안전하지만 느리다.

이 연산자를 사용하려면 '하나 이상의 virtual 함수' 가 존재해야한다.

class super

{

};

class sub : public super

{

};

int main()

{

sub* ss = dynamic_cast<sub*>(new super());

}

위 코드는 실행이 불가능하다

해당 클래스가 '다형 형식'이 아니라고 경고문이 나온다.

그럼 다형 형식이란?

위에서. 이 dynamic_cast연산자를 사용하려면

하나 이상의 virtual함수 가 존재해야한다.

virtual함수. 즉 가상 함수는 오버라이딩을통해 '다형성'을 구축한다.

class super

{

public:

virtual void func()

{

prtinf_s("부모의 가상 함수.\n");

}

};

class sub : public super

{

};

int main()

{

sub* ss = dynamic_cast<sub*>(new super());

if(ss == NULL)

{

prtinf_s("변환 실패\n");

}

ss->func();

}

4. reinterpret_cast

타입이니 뭐니 하는 것을 따지지 않고 무조건적으로 변환해버린다.

(reinterpret 다시 해석하다, 새로해석하다)

대단히 위험한 방법으로, 안전하다는 보장이 없다.

void main()

{

int a = 123;

double *b = nullptr;

b = reinterpret_cast<double*>(a);

printf_s("%d\n", a);

printf_s("%d\n", b);

}

C++ 증감연산자 (전,후) 구현

꽈이렁 — Fri, 25 Jan 2019 07:38:44 +0900

c++ 증감연산자

num++

++num

의 차이.

int num = 10

printf_s("num : %d\n", num)

printf_s("num : %d\n", ++num)

printf_s("num : %d\n", num++)

printf_s("num : %d\n", num)

가있을때 실행결과는

num : 10

num : 11

num : 12

이다.

++num은 실행 전 1을더한다

num++은 실행 후 1을 더한다.

printf_s("num : %d\n", num++)

이부분 에서 num은 위에 ++num의 결과로 11이된 상태다.

이때 num++은 printf 구문에서 11을 출력한 다음 ++이되어 12가 된다

그래서 아래 printf_s("num : %d\n", num) 부분에서 num이 12로 출력이된다.

이 전위 후위 증감 연산자를 코드로 구현해보았다.

int transposition(int* _num)

{

int* transnum = _num;

*transnum += 1;

return *transnum;

}

int postposition(int * _num)

{

int* transnum = _num;

int save = (*transnum);

*transnum += 1;

return save;

}

int main()

{

int num = 10;

printf_s("num : %d\n", num);

printf_s("++num : %d\n", transposition(&num));

printf_s("num++ : %d\n", postposition(&num));

printf_s("num : %d\n", num);

}

C++ memcpy_s 함수 구현

꽈이렁 — Fri, 25 Jan 2019 07:32:35 +0900

memcpy_s 함수는

메모리를 복사해주는 함수이다.

memcpy_s(void * dest,size_t size, const void * source, size_t n);

dest : 복사 대상 버퍼

size : 복사 대상 버퍼 크기

source : 복사할 원본

n :복사할 바이트 수

반환 값

에러 번호

코드는 아래와 같다.

-코드-

int Strlen(char* _pC)

{

int Count = 0;

while (0 != _pC[Count])

{

Count += 1;

}

return Count;

}

배열의 크기를 알수있게 Strlen함수도 구현을 했다.

void Mymemcpy_s(void* _pCopy, int _CopySize, void* _pOriginal, int _OriginalSize)

{

int Count = 0;

char* Copy = (char*)_pCopy;

char* Original = (char*)_pOriginal;

if (_OriginalSize > _CopySize)

{

printf_s("복사 실패.\n");

while (_CopySize != Count)

{

Copy[Count] = 0;

Count += 1;

}

else

{

while (_OriginalSize != Count)

{

Copy[Count] = Original[Count];

Count += 1;

}

int main()

{

char TestCopy1[256];

char TestOriginal1[256] = "Assortrock";

char TestCopy2[512];

char TestOriginal2[256] = "YangYoungGwan";

Mymemcpy_s(TestCopy1, sizeof(TestCopy1), TestOriginal1, sizeof(TestOriginal1));

Mymemcpy_s(TestCopy2, sizeof(TestCopy2), TestOriginal2, sizeof(TestOriginal2));

printf_s("Original1 : %s \n", TestOriginal1);

printf_s("Copy : %s \n\n", TestCopy1);

printf_s("Original2 : %s \n", TestOriginal2);

printf_s("Copy : %s \n\n", TestCopy2);

}

C++ memset 함수 구현

꽈이렁 — Fri, 25 Jan 2019 07:23:47 +0900

memset 함수는

어떤 메모리의 시작점부터 연속된 범위를 어떤 값으로(바이트 단위) 모두 지정하고 싶을 때 사용하는 함수이다.

구조는

memset ( void * ptr, int value, size_t num );

ptr : 채우고자 하는 메모리의 시작 포인터(시작 주소)

value : 메모리에 채우고자하는 값. int형이지만 내부에서는 unsigned char(1 byte)로 변환되어서 저장된다.

num : 채우고자 하는 바이트의 수. 즉, 채우고자 하는 메모리의 크기

memset함수를 구현해보면 아래 코드와 같다.

-코드-

void* MYMEMSET(void* _StartPtr

, int _Data

, unsigned int _Number)

{

char* PStartPtr = (char*)_StartPtr;

for(int i = 0 ; i < _Number ; i++)

{

PStartPtr[i] = _Data;

}

return _StartPtr;

}

리턴하는 값이 배열 형이기때문에

void*형으로 함수를 선언하고.

void* _StartPtr 배열의 시작 주소를 받아온다.

int _Data 입력될 값을 받아온다.

unsigned int _Number 범위를 받아온다.

int main()

{

//배열

char Test[100];

//값 확인

for (int i = 0; i < 100; i++)

{

printf_s("%d ", Test[0]);

}

printf("다음 \n");

//함수

MYMEMSET(Test, 1, sizeof(Test));

//값 확인

for (int i = 0; i < 100; i++)

{

printf_s("%d ", Test[0]);

}

C++ 포인터

꽈이렁 — Fri, 25 Jan 2019 06:38:03 +0900

C++ 포인터는 2가지만 알면된다

1. * 참조 연산자

2. & 주소 연산자

포인터는 다른 변수의 위치를 가르키는 변수이다.

예를들어

int a = 10 이라는 변수가 선언되었다.

여기서 a는

자료형 int

크기 4바이트
형태 정수형

값이 10인

주소의 이름이 a이다.

그럼 주소의 이름이 a면 주소의 값은?

& 주소 연산자를 통해 끌어낼 수 있다.

int a = 10

int* pa = &a

자료형 int

크기 4바이트
형태 정수형

값이 10인

주소의 이름이 a인 변수 a를 선언한후

자료형이 int 포인터 인 pa를 선언해서

&a <- a의 주소를 넣어 준다.

그럼 pa는 a의 주소값을 가진 변수가 되는것이다.

아 int 포인터의 크기는

32비트 환경에서는 4바이트

64비트 환경에서는 8바이트이다.

그럼 포인터는 주소를 가르키는 변수인데 증명을 하고 싶으면.

아래와 같은 방법으로 증명 할 수 있다.

int a = 10;

int b = 20;

int* pa = &a;

int* pb = &b;

printf_s("%d\n", pa);

printf_s("%d\n", pb);

이와 같은 코드를 실행 했을때

7731072

7731060

라는 실행결과를 얻을수있다.(메모리의 할당은 자동으로 할당되는것이기때문에 주소값은 실행시 바뀐다.)

pa와 pb의 주소값의 차이가 12바이트가 차이가나는데.

그럼 pb의 값을 + 12 해서 새로운 pc라는 포인터에 넣어주면

pc는 a를 가르키는 포인터가 되어야한다.

아래의 코드를 보자

int a = 10;

int b = 20;

int* pa = &a;

int* pb = &b;

printf_s("pa : %d\n", pa);

printf_s("pb : %d\n", pb);

printf_s("*pa : %d\n", *pa);

printf_s("*pb : %d\n", *pb);

int* pc = pb + 3;

printf_s("int *pc = pb + 3\n");

printf_s("pc : %d\n", pc);

printf_s("*pc : %d\n", *pc);

위와 같은코드에

int* pc = pb + 3; 이라는 코드를 활용해 주소값을 바꿔보았다.

여기에서 12바이트가 차이나는데 3이라는 상수를 더한 이유는

저 3이라는 상수 앞에 sizeof(int) * 3 의 코드가 숨겨져 있기 때문이다.

실행결과는 예상과 같이 아래와 같다.

-실행결과-

pa : 9829708

pb : 9829696

*pa : 10

*pb : 20

int *pc = pb + 3

pc : 9829708

*pc : 10

이렇게 불편해 보이는 포인터를 쓰는 이유는.

1. 배열은 포인터를 사용하여 구현된다. 포인터는 배열을 반복할 때 사용할 수 있다. (배열 인덱스 대신 사용 가능)

2. C++에서 동적으로 메모리를 할당할 수 있는 유일한 방법이다. (가장 흔한 사용 사례)

3. 데이터를 복사하지 않고도 많은 양의 데이터를 함수에 전달할 수 있다.

4. 함수를 매개 변수로 다른 함수에 전달하는 데 사용할 수 있다.

5. 상속을 다룰 때 다형성을 달성하기 위해 사용한다.

6. 하나의 구조체/클래스 포인터를 다른 구조체/클래스에 두어 체인을 형성하는 데 사용할 수 있다. 이는 연결리스트 및 트리와 같은 고급 자료구조에서 유용하다.

C++ WHILE ,DO WHILE (반복문)

꽈이렁 — Fri, 25 Jan 2019 03:18:26 +0900

while은 for과 같이 반복문이다.

int Count = 0;

while (Count != 0)

{

printf("내부코드");

}

조건 : Count != 0

내부코드 : { printf("내부코드"); }

동작 순서는.

while은 조건-> 내부코드 순이면

do while은 내부코드 -> 조건 순이다

그렇기에 do while문은 내부코드가 무조건 1번은 실행된다.

// 조건 -> 내부코드

// 조건 참이면

int Count = 0;

while (Count != 0)

{

printf_s("%d\n", Count);

Count += 1;

}

// 내부코드 -> 조건

// 내부코드를 한번은 꼭 실행해준다.

Count = 0;

{

printf_s("%d\n", Count);

Count += 1;

} while (Count == 0);

C++ for (반복문)

꽈이렁 — Fri, 25 Jan 2019 03:08:28 +0900

for 반복문

for (int i = 0; i < 100; i++)

{

prtinf("%d",i);

}

코드가 있을때.

int i = 0 = 초기화문 (시작 조건)

i < 100 = 조건문 (종결 조건)

i++ = 증감문 (조건 변화식)

{ printf("%d",i) } = 내부코드

순서

초기화문 ->

조건문 -> 내부코드 -> 증감문

의 반복이다.

for (int i = 0; i < 100; i++)

{

}

for (int a = 0; a < 100;)

{

}

for (int b = 0;;)

{

}

int c = 0;

for ( ; c < 100 ; c++)

{

}

int d = 0;

for (;; d++)

{

}

for(;;)

{

}

초기화문, 조건문, 증감문이 없어도 for문은 실행된다.

조건문(종결 조건)이 명확하지 않으면 무한 루프에 빠진다.

C++ SWITCH CASE (제어문)

꽈이렁 — Fri, 25 Jan 2019 02:50:20 +0900

switch case

if, else if, else 문으로 여러 조건을 비교할 수 있었지만 가독성이 좋지 않다.

if 문은 되도록이면 최선을 다해 한 두가지 경우의 수가 나오는 경우에만 사용하는 편이 코드를 다시 읽게 될 때 이해하기가 편하다.

여러 경우의 수가 나오는 경우 swtich case 문을 사용할 수 있다.

문법:

switch (비교할 대상)

{

case 비교값1:

break;

case 비교값2

break;

deafult:

break;

}

switch (비교 대상)

비교할 대상으로 올수 있는 값은 기본 타입

char, short, int, long, float, double

case 비교값:

상수값만 올 수 있다.

case 문은 마치 if (비교대상 == 비교값) 같은 역할을 한다.

case 문의 끝은 반드시 break; 로 처리해야 한다.

default:

마치 if, else if 후 else 구문 같은 역할을 한다.

case 문에 모두 만족하지 않으면 default 구문이 실행된다.

예)

int done = 0;

char c = getchar();

switch (c) {

case 'q':

done = 1;

break;

default:

break;

}

switch case 의 함정

break 문

case 조건문1:

case 조건문2:

break;

조건문1 과 조건문2 사이에 break 문이 없다.

만약에 조건문1과 일치하여 조건문1이 수행되고 나면 조건문2가 실행된다.

break; 문을 만나지 않으면 계속 실행이 된다.

간혹 이러한 특성이 도움이 되기도 하지만 실수로 break; 문을 빠뜨리는 경우가 많다.

주의하자.

-코드-

#include "pch.h"

#include <iostream>

#include <conio.h> // _getch()를 실행하기 위해 참조.

// 자동완성기능의 강력함은 ENUM과 같이 써봐야 한다.

enum PLAYERJOB

{

FIGHTER,

ARCHER,

MAGE,

};

int main()

{

int Number = 2;

int b = 0;

int c = 100;

switch (Number)

{

case 0:

{

// 지역변수의 내부 선언이 안된다.

// 사용은 된다.

// 쓸려면 이렇게 스택을 따로 만들어내는 수가 있다.

// int d = 100; 는 에러를.

// int d;

// d = 100; //된다

c = 100;

printf_s("case 0:\n");

break;

}

case 1:

printf_s("case 1:\n");

break;

case 2:

printf_s("case 2:\n");

break;

default:

printf_s("Default:\n");

break;

}

__int8 i8 = 'b';

char ch = '0';

switch (_getch())

{

case 'a':

case 'A':

printf_s("a || A\n");

break;

case 'b':

case 'B':

printf_s("b || B\n");

break;

case 'c':

case 'C':

printf_s("c || C\n");

break;

default:

break;

}

C++ atoi(StringToInt) ,itoa(IntToString) 구현하기

꽈이렁 — Fri, 25 Jan 2019 01:44:38 +0900

atoi 함수는

char Arr[10] = "987654"

int Value

Arr배열의 "987654"를 int형인 987654로 변환해주고

itoa 함수는

char Arr[10]

int Value = 987654

int 987654를 Arr배열에 "987654"로 바꿔주는 함수이다.

아래 코드와 같이 구현해보았다.

#include "pch.h"

#include <iostream>

int StringToInt(char* _char)

{

int value = 0;

while (*_char) // NULL까지

{

value = (value * 10) + *_char - '0';

// 자리수를 올려주며 수를 가져옴 char(숫자(0~) - 0char(숫자(0)) int숫자.

_char++; // 다음 문자 주소로 넘김

}

return value;

}

void IntToString(int _num, char* _char)

{

int i = 0;

int radix = 10; // 진수

int deg = 1; // 자리수 만약 12345가 들어오면 10000가될거고

int count = 0; // 자리수 count는 4가될거다.

while (1) // 자리수의 수를 뽑는다

{

if ((_num / deg) > 0)

{

count++;

}

else

{

deg /= radix; //한자리수 더 높게 연산되어 한번 나누어준다.

break;

}

deg *= radix;

}

for (i = 0; i < count; i++) // 자리수만큼 순회

{

*(_char + i) = _num / deg + '0'; //가장 큰 자리수 12345면 배열0번째 자리에 12345 / 10000 = int 1

_num -= ((_num / deg) * deg); //12345 - ((12345 / 10000) * 10000) = 2345

deg /= radix; //10000 / 10 = 1000

}

*(_char + i) = '\0'; // 문자열의 끝은 NULL

}

int main()

{

char Arr[10] = "987654";

int Value = StringToInt(Arr);

printf_s("%d\n", Value);

int Value2 = 456789;

char Arr2[10];

IntToString(Value2, Arr2);

printf_s("%s\n", Arr2);

}

C++ IF (조건문)

꽈이렁 — Thu, 24 Jan 2019 00:56:42 +0900

C++에서 가장 기본적인 조건문은 if 명령문이다. (if statement)

-----------코드-----------

if(expression1)

{

//expression1 = true 실행

}

else if(expression2)

{

//expression2 = true 실행

}

else

{

//expression1 = true || expression2 = true 외 실행

}

-----------코드-----------

위에서 'expression'을 조건식(conditional expression)이라고 한다.

조건식이 true(0이 아님)로 평가되면 if 문이 실행된다. 표현식이 false로 평가되면 else 문이 실행된다(else 문이 있는 경우).

-----------코드-----------

#include "pch.h"

#include <iostream>

int main()

{

if (true)

{

printf_s("TRUE 실행\n");

}

if (false)

{

printf_s("FALSE 실행\n");

}

if (0)

{

printf_s("0 실행\n");

}

if (42389472389)

{

printf_s("42389472389 실행\n");

}

if (0 && 312321)

{

printf_s("if (0 && 312321) 실행\n");

}

int b = 1;

if (b)

{

printf_s("if (b) 실행\n");

}

if (b)

printf_s("if (b) 실행\n");

if (0 != b)

{

printf_s("if (b) 실행\n");

}

if (1, 2)

{

printf_s("if (1, 2) 실행\n");

}

if (1, 2, 3)

{

printf_s("if (1, 2, 3) 실행\n");

}

// 가장 오른쪽만 본다.

if (0, 0, 3)

{

printf_s("if (0, 0, 3) 실행\n");

}

if (false)

{

}

else if (false)

{

printf_s("else if (true)1 실행\n");

}

else if (false)

{

printf_s("else if (false)2 실행\n");

}

else {

printf_s("else 실행\n");

}

----------실행 결과----------

TRUE 실행

42389472389 실행

if (b) 실행

if (1, 2) 실행

if (1, 2, 3) 실행

if (0, 0, 3) 실행

else 실행

와 같다.

C++ 논리연산자

꽈이렁 — Wed, 23 Jan 2019 06:39:13 +0900

C++ 논리연산자에는

1. !a (a가 true면 false로)

2. a && b (a와 b가 둘다 참이면 참)

3. a || b (a와 b중 하나만 참이여도 참)

가 존재한다.

아래와 같은 코드가 있을때

int FuncTrue()

{

printf_s("FuncTrue Progress\n");

return 1;

}

int FuncFalse()

{

printf_s("FuncFalse Progress\n");

return 0;

}

int Left = 3;

int Right = 7;

bool Result;

Result = !Left;

printf_s("!Left 3 %d\n", Result);

Result = Left && Right;

printf_s("Left 3 && Right 7 %d\n", Result);

Result = Left || Right;

printf_s("Left 3 || Right 7 %d\n", Result);

1. Result = FuncTrue() || FuncFalse();

2. Result = FuncFalse() && FuncTrue() && FuncTrue();

Result = !Right;

printf_s("!Right 7 %d\n", Result);

1. FuncFalse() 와 2. FuncTure&& FuncTrue() 부분이 실행될것이라고 오해하는 경우가 많다.

실행결과

1. !Left 3 0

2. Left 3 && Right 7 1

3. Left 3 || Right 7 1

4. FuncTrue Progress

5. FuncFalse Progress

6. !Right 7 0

1. 3은 true !연산자 -> 0(false)

2. 3,7은 true &&연산자 -> 1(true)

3. 3,7은 true ||연산자 -> 1(true)

4. ||연산자는 한쪽만 true여도 true를 리턴한다 그래서 FuncTure()함수가 실행되고 true인걸 확인하고 뒤에있는 FuncFlase()를 실행하지않는다.

5. &&연산자는 양쪽이 true야 true를 리턴한다. 그래서 FuncFalse(0함수가 먼저 실행되고 false를 리턴받아 뒤에있는 FuncTrue() && FuncTrue() 나머지 함수가 실행하지 않는다.

6. 7은 true !연산자 -> 0(false)

꽈이입니다.

꽈이렁 — Wed, 23 Jan 2019 06:24:17 +0900

꽈이입니다.

꽈하!

C++ 비교연산자

꽈이렁 — Wed, 23 Jan 2019 06:19:49 +0900

C++ 비교연산자에는

1. a == b (a와 b는 같다)

2. a != b (a와 b는 다르다)
3. a > b (a가 b보다 크다)

4. a < b (a가 b보다 작다)
5. a >= b (a가 b보다 크거나 같다)
6. a <= b (a가 b보다 작거나 같다)

가 존재한다.

비교연산자는 참이면 true 거짓이면 false 프로그래밍은 무조건 비트 어떤 데이터의 범위가 있을때

단 한개의 비트라도 1이 있다면 참(1), 모두 0이라면 거짓(0) 이다.

리턴 값은

true = 1

false = 0

이다.

C++ 비트연산자

꽈이렁 — Wed, 23 Jan 2019 05:52:16 +0900

C++ 비트연산자에는

1. AND

2. OR

3. XOR

4. NOT

5. 왼쪽 쉬프트

6. 오른쪽 쉬프트

6가지가 존재한다.

C++ 콘솔RPG게임[클래스사용, 간단..]

꽈이렁 — Wed, 23 Jan 2019 01:34:07 +0900

#include "pch.h"

#include <iostream>

#include <conio.h>

int PLEVEL = 1;

class RpgMonster

{

private:

int MATT;

int MHP;

int MLEVEL = 1;

public:

int GETATT()

{

return MATT;

}

int GETMHP()

{

return MHP;

}

public:

void StatusRender()

{

printf_s("몬스터-------------------------\n");

printf_s("레 벨 : %d\n", this->MLEVEL);

printf_s("공격력 : %d\n", this->MATT);

printf_s("체 력 : %d\n", this->MHP);

printf_s("-------------------------------\n");

}

void Damage(int _ATT)

{

MHP -= _ATT;

HpControl();

this->StatusRender();

printf_s("플레이어가 %d의 공격력으로 몬스터를 때렸다.\n", _ATT);

_getch();

printf_s("몬스터는 HP가 %d 만큼 남았다.\n", MHP);

DieCheck();

}

void HpControl()

{

if (MHP < 0)

{

MHP = 0;

}

void DieCheck()

{

if (MHP == 0)

{

printf_s("몬스터가 죽었습니다.\n");

MLEVEL += 1;

PLEVEL += 1;

MHP = 50 * MLEVEL;

MATT = 2 * MLEVEL;

}

public:

RpgMonster() : MATT(2), MHP(50)

{

}

RpgMonster(int _ATT, int _HP) : MATT(_ATT), MHP(_HP)

{

}

};

class RpgPlayer

{

private:

int PATT;

int PHP;

public:

int GETATT()

{

return PATT;

}

int GETPHP()

{

return PHP;

}

void SETPLEVEL()

{

PLEVEL += 1;

}

void StatusRender()

{

printf_s("플레이어-----------------------\n");

printf_s("레 벨 : %d\n", PLEVEL);

printf_s("공격력 : %d\n", this->PATT);

printf_s("체 력 : %d\n", this->PHP);

printf_s("-------------------------------\n");

}

void Damage(int _ATT,RpgMonster _RM)

{

RpgMonster __RM = _RM;

PHP -= _ATT;

HpControl();

this->StatusRender();

__RM.StatusRender();

printf_s("몬스터가 %d의 공격력으로 플레이어를 때렸다.\n", _ATT);

_getch();

printf_s("플레이어는 HP가 %d 만큼 남았다.\n", PHP);

DieCheck();

}

void HpControl()

{

if (PHP < 0)

{

PHP = 0;

}

void DieCheck()

{

if (PHP == 0)

{

printf_s("플레이어가 죽었습니다.\n");

}

public:

RpgPlayer(int _ATT, int _HP) : PATT(_ATT), PHP(_HP)

{

}

};

int main()

{

RpgPlayer RP = { 10, 200 };

RpgMonster RM;

RP.StatusRender();

RM.StatusRender();

while (true)

{

_getch();

system("cls");

RP.StatusRender();

RM.Damage(RP.GETATT());

_getch();

system("cls");

RP.Damage(RM.GETATT(),RM);

if (0 >= RP.GETPHP())

{

break;

}

_getch();

}

간단한 소스입니다.. 과제에 사용하시면 F..

C++ 콘솔슈팅게임[클래스 미사용, 간단..]

꽈이렁 — Wed, 23 Jan 2019 01:32:15 +0900

#include "pch.h"

#include <iostream>

#include <conio.h>

#include <stdlib.h>;

#include <time.h>;

int rand_X()

{

int Rand_X = rand() % 49;

return Rand_X;

}

int rand_Y()

{

int Rand_Y = rand() % 15;

return Rand_Y;

}

int main()

{

int MapSizeY = 20;

int MapSizeX = 52;

int KillCount = 0;

int MonsterCount = 3;

int FrameCount = 0;

int BoomCount = 0;

bool Boom = false;

int BoomX = 0;

int BoomY = 0;

int PlayerX = 25;

int PlayerY = 18;

int MonsterX_1 = 10;

int MonsterX_2 = 28;

int MonsterX_3 = 42;

int MonsterY_1 = 3;

int MonsterY_2 = 5;

int MonsterY_3 = 7;

char ArrPixel[20][52];

memset((void*)ArrPixel, '*', sizeof(char) * MapSizeY * MapSizeX);

for (int y = 0; y < 20; y++)

{

ArrPixel[y][50] = '\n';

ArrPixel[y][51] = 0;

}

ArrPixel[MonsterY_1][MonsterX_1] = 'M';

ArrPixel[MonsterY_2][MonsterX_2] = 'M';

ArrPixel[MonsterY_2][MonsterX_3] = 'M';

while (true)

{

system("cls");

ArrPixel[PlayerY][PlayerX] = '@';

for (int y = 0; y < MapSizeY; y++)

{

printf_s(ArrPixel[y]);

}

printf_s("---------------------------------------------------- \n");

printf_s("MONSTER : %d KILL : %d \n",MonsterCount ,KillCount);

printf_s("-----------------------조작법----------------------- \n");

printf_s("이동 : W A S D \n");

printf_s("총알 : K \n");

printf_s("폭탄 : B \n");

printf_s("몬스터가 있는곳으로는 이동할 수 없습니다.\n");

printf_s("폭탄이 터지는 동안 폭탄을 재사용 할 수 없습니다.\n");

printf_s("승리 : 20 Kill\n");

printf_s("패배 : 20 MONSTER\n");

printf_s("---------------------------------------------------- \n");

if (Boom == true)

{

BoomCount += 1;

}

if (BoomCount == 1)

{

if (ArrPixel[BoomY][BoomX - 1] == 'M'

|| ArrPixel[BoomY][BoomX + 1] == 'M'

|| ArrPixel[BoomY + 1][BoomX] == 'M'

|| ArrPixel[BoomY - 1][BoomX] == 'M')

{

KillCount += 1;

MonsterCount -= 1;

}

ArrPixel[BoomY][BoomX - 1] = 'B';

ArrPixel[BoomY][BoomX + 1] = 'B';

ArrPixel[BoomY + 1][BoomX] = 'B';

ArrPixel[BoomY - 1][BoomX] = 'B';

}

else if (BoomCount == 2)

{

if (ArrPixel[BoomY][BoomX - 2] == 'M'

|| ArrPixel[BoomY][BoomX + 2] == 'M'

|| ArrPixel[BoomY + 2][BoomX] == 'M'

|| ArrPixel[BoomY - 2][BoomX] == 'M')

{

KillCount += 1;

MonsterCount -= 1;

}

ArrPixel[BoomY][BoomX - 2] = 'B';

ArrPixel[BoomY][BoomX + 2] = 'B';

ArrPixel[BoomY + 2][BoomX] = 'B';

ArrPixel[BoomY - 2][BoomX] = 'B';

}

else if (BoomCount == 3)

{

if (ArrPixel[BoomY][BoomX - 3] == 'M'

|| ArrPixel[BoomY][BoomX + 3] == 'M'

|| ArrPixel[BoomY + 3][BoomX] == 'M'

|| ArrPixel[BoomY - 3][BoomX] == 'M')

{

KillCount += 1;

MonsterCount -= 1;

}

ArrPixel[BoomY][BoomX - 3] = 'B';

ArrPixel[BoomY][BoomX + 3] = 'B';

ArrPixel[BoomY + 3][BoomX] = 'B';

ArrPixel[BoomY - 3][BoomX] = 'B';

}

else if (BoomCount == 4)

{

if (ArrPixel[BoomY][BoomX - 4] == 'M'

|| ArrPixel[BoomY][BoomX + 4] == 'M'

|| ArrPixel[BoomY + 4][BoomX] == 'M'

|| ArrPixel[BoomY - 4][BoomX] == 'M')

{

KillCount += 1;

}

ArrPixel[BoomY][BoomX - 4] = 'B';

ArrPixel[BoomY][BoomX + 4] = 'B';

ArrPixel[BoomY + 4][BoomX] = 'B';

ArrPixel[BoomY - 4][BoomX] = 'B';

}

else if (BoomCount == 5)

{

for (int i = -4; i < 5; i++)

{

ArrPixel[BoomY + i][BoomX] = '*';

ArrPixel[BoomY][BoomX + i] = '*';

}

Boom = false;

BoomCount = 0;

}

if (KillCount == 20)

{

printf_s("Game Clear......");

break;

}

if (MonsterCount == 20)

{

printf_s("Game Over......");

break;

}

for (int i = 0; i < MapSizeY; i++)

{

for (int j = 0; j < MapSizeX; j++)

{

if (ArrPixel[i][j] == '^')

{

ArrPixel[i][j] = '*';

if (ArrPixel[i - 1][j] == 'M')

{

ArrPixel[i - 1][j] = '*';

KillCount += 1;

MonsterCount -= 1;

}

else

{

if (i - 1 > 0)

{

ArrPixel[i - 1][j] = '^';

}

switch (_getch())

{

case 'a':

case 'A':

if (PlayerX != 0 && ArrPixel[PlayerY][PlayerX - 1] != 'M')

{

ArrPixel[PlayerY][PlayerX] = '*';

ArrPixel[PlayerY][PlayerX - 1] = '@';

PlayerX -= 1;

}

break;

case 'd':

case 'D':

if (PlayerX != (MapSizeX -3) && ArrPixel[PlayerY][PlayerX + 1] != 'M')

{

ArrPixel[PlayerY][PlayerX] = '*';

ArrPixel[PlayerY][PlayerX + 1] = '@';

PlayerX += 1;

}

break;

case 'w':

case 'W':

if (PlayerY != 0 && ArrPixel[PlayerY - 1][PlayerX] != 'M')

{

ArrPixel[PlayerY][PlayerX] = '*';

ArrPixel[PlayerY - 1][PlayerX] = '@';

PlayerY -= 1;

}

break;

case 's':

case 'S':

if (PlayerY != (MapSizeY -1) && ArrPixel[PlayerY + 1][PlayerX] != 'M')

{

ArrPixel[PlayerY][PlayerX] = '*';

ArrPixel[PlayerY + 1][PlayerX] = '@';

PlayerY += 1;

}

break;

case 'r':

case 'R':

break;

case 'k':

case 'K':

if (ArrPixel[PlayerY - 1][PlayerX] == 'M')

{

KillCount += 1;

MonsterCount -= 1;

}

ArrPixel[PlayerY - 1][PlayerX] = '^';

break;

case 'b':

case 'B':

if (Boom == false

&& PlayerY -3 -4 > -1

&& PlayerY -3 +4 < 20

&& PlayerX -4 > -1

&& PlayerX +4 < 50)

{

if (ArrPixel[PlayerY - 3][PlayerX] == 'M')

{

KillCount += 1;

MonsterCount -= 1;

}

Boom = true;

ArrPixel[PlayerY - 3][PlayerX] = 'B';

BoomY = PlayerY - 3;

BoomX = PlayerX;

break;

}

FrameCount += 1;

if (FrameCount % 10 == 0)

{

ArrPixel[rand_Y()][rand_X()] = 'M';

MonsterCount += 1;

}

간단한 소스입니다 과제에 사용하시면 F...

C++ 콘솔슈팅게임[클래스사용, 간단..]

꽈이렁 — Wed, 23 Jan 2019 01:27:24 +0900

#include "pch.h"

#include <iostream>

#include <conio.h>

#define GAMEX 20

#define GAMEY 10

#define PLAYERSTARTX (GAMEX - 2) / 2

#define PLAYERSTARTY (GAMEY / 3) * 2

#define OVERX GAMEX - 2

#define OVERY GAMEY

#define LINEINDEX GAMEX - 2

#define ZEROINDEX GAMEX - 1

#define BASECHAR '*'

#define BULLETMAX 100

class Pos

{

public:

int X;

int Y;

public:

Pos() : X(0), Y(0)

{

}

Pos(int _X, int _Y) : X(_X), Y(_Y)

{

}

};

class ConsoleScreen

{

private:

char ArrPixel[GAMEY][GAMEX];

public:

void PrintScreen()

{

system("cls");

for (int y = 0; y < GAMEY; y++)

{

printf_s(ArrPixel[y]);

}

public:

void SetPixel(Pos _Pos, char _Pixel)

{

ArrPixel[_Pos.X][_Pos.Y] = _Pixel;

}

void SetPixel(int _X, int _Y, char _Pixel)

{

ArrPixel[_Y][_X] = _Pixel;

}

public:

void ScreenInit()

{

memset((void*)ArrPixel, BASECHAR, sizeof(char) * GAMEY * GAMEX);

for (int y = 0; y < GAMEY; y++)

{

ArrPixel[y][LINEINDEX] = '\n';

ArrPixel[y][ZEROINDEX] = 0;

}

};

class ScreenObj

{

private:

Pos m_ScreenPos;

bool IsOnOff;

ConsoleScreen* m_pScreen;

protected:

char RenderCh;

public:

int GetX() const

{

return m_ScreenPos.X;

}

int GetY() const

{

return m_ScreenPos.Y;

}

void SetRenderCh(char _ch)

{

RenderCh = _ch;

}

public:

void On() {

IsOnOff = true;

}

void Off() {

IsOnOff = false;

}

public:

void PosSet(Pos _Pos)

{

m_ScreenPos = _Pos;

}

void PosSet(int _X, int _Y)

{

m_ScreenPos.X = _X;

m_ScreenPos.Y = _Y;

}

void MoveLeft() { --m_ScreenPos.X; }

void MoveRight() { ++m_ScreenPos.X; }

void MoveUp() { --m_ScreenPos.Y; }

void MoveDown() { ++m_ScreenPos.Y; }

public:

void SetScreen(ConsoleScreen* _pScreen)

{

m_pScreen = _pScreen;

}

public:

void Render()

{

if (false == IsOnOff)

{

return;

}

if (-1 >= m_ScreenPos.X)

{

return;

}

if (-1 >= m_ScreenPos.Y)

{

return;

}

if (OVERX <= m_ScreenPos.X)

{

return;

}

if (OVERY <= m_ScreenPos.Y)

{

return;

}

m_pScreen->SetPixel(m_ScreenPos.X, m_ScreenPos.Y, RenderCh);

}

public:

ScreenObj() : m_ScreenPos(-1, -1), RenderCh(' '), IsOnOff(true)

{}

};

class Bullet : public ScreenObj

{

public:

void Update()

{

MoveUp();

}

public:

Bullet()

{

RenderCh = '^';

}

};

class FlyPlayer : public ScreenObj

{

private:

bool FireCheck;

int BulletCount = 0;

public:

bool IsFire()

{

bool Check = FireCheck;

FireCheck = false;

return Check;

}

int GetBulletCount()

{

return BulletCount;

}

public:

void Control()

{

FireCheck = false;

switch (_getch())

{

case 'a':

case 'A':

MoveLeft();

break;

case 'd':

case 'D':

MoveRight();

break;

case 'w':

case 'W':

MoveUp();

break;

case 's':

case 'S':

MoveDown();

break;

case 'r':

case 'R':

break;

case 'f':

case 'F':

FireCheck = true;

BulletCount += 1;

if (BulletCount == BULLETMAX)

{

BulletCount = 1;

}

break;

}

public:

FlyPlayer()

{

RenderCh = '@';

}

};

int main()

{

ConsoleScreen Screen = ConsoleScreen();

Screen.ScreenInit();

FlyPlayer NewPlayer = FlyPlayer();

NewPlayer.SetScreen(&Screen);

NewPlayer.SetRenderCh('@');

NewPlayer.PosSet(PLAYERSTARTX, PLAYERSTARTY);

Bullet OneBullet[BULLETMAX];

for (int i = 0; i < BULLETMAX; i++)

{

OneBullet[i].SetScreen(&Screen);

OneBullet[i].SetRenderCh('^');

OneBullet[i].Off();

}

while (true)

{

size_t Test = 0;

int BulletCount = NewPlayer.GetBulletCount();

for (size_t i = 0; i < 20000000; ++i)

{

Test = i;

}

NewPlayer.Render();

for (int i = 0; i < BULLETMAX; i++)

{

OneBullet[i].Render();

OneBullet[i].Update();

}

Screen.PrintScreen();

Screen.ScreenInit();

if (1 == _kbhit())

{

NewPlayer.Control();

}

if (true == NewPlayer.IsFire())

{

OneBullet[BulletCount].PosSet(NewPlayer.GetX(), NewPlayer.GetY());

OneBullet[BulletCount].On();

}

간단한 코드니 과제에 사용하시면 아마 F나옵니다 ㅠ