1. Stack


#include <iostream>
using namespace std;

template <typename T>
struct _tagNode{	
	_tagNode* p_nextNode;
	T m_data;
};

template <typename T> 
struct _tagStack{
	_tagNode<T>*	TOS;
	unsigned int	iSize;

	_tagStack() :iSize(0), TOS(NULL) {
	}

	void push(_tagNode<T>* nodeToPush) {
		nodeToPush->p_nextNode = (iSize != 0) ? TOS : NULL;
		TOS = nodeToPush;
		++iSize;
	}

	_tagNode<T>* pop() {
		if (iSize == 0) 
		{
			cout << "underflow" << endl;
			system("pause");
			exit(1);
		}
		_tagNode<T>* temp;
		temp = TOS;
		TOS = TOS->p_nextNode;
		--iSize;
		return temp;
	}
};

int main() {
	_tagNode<int> iTagArr[10];
	_tagStack<int> iStk;

	_tagNode<float> fTagArr[10];
	_tagStack<float> fStk;

	for (int i = 0; i < 10; ++i)
	{
		iTagArr[i].m_data = i;
		fTagArr[i].m_data = (float)i * 0.1f;
		iStk.push(&iTagArr[i]);
		fStk.push(&fTagArr[i]);
	}

	for (int i = 0; i < 10; ++i)
		cout << iStk.pop()->m_data << endl;

	for (int i = 0; i < 10; ++i)
		cout << fStk.pop()->m_data << endl;

	system("pause");
	return 0;
}


2. Queue 


#include <iostream>
using namespace std;

template <typename T>
struct _tagNode {
	_tagNode* p_nextNode;
	T m_data;
};

template <typename T>
struct _tagQueue {
	_tagNode<T>*	TOQ;
	_tagNode<T>*	prevNode;
	unsigned int	iSize;
	_tagQueue() :iSize(0), TOQ(NULL), prevNode(NULL) {
	}

	void Enqueue(_tagNode<T>* nodeToPush) {
		if (iSize == 0) 
		{
			TOQ = nodeToPush;
		}
		else {
			prevNode->p_nextNode = nodeToPush;
		}
		prevNode = nodeToPush;
		++iSize;
	}

	_tagNode<T>* Dequeue() {
		if (iSize == 0)
		{
			cout << "underflow" << endl;
			system("pause");
			exit(1);
		}
		_tagNode<T>* temp;
		temp = TOQ;
		TOQ = TOQ->p_nextNode;
		--iSize;
		return temp;
	}
};

int main() {
	_tagNode<int> iTagArr[10];
	_tagQueue<int> iQueue;

	_tagNode<float> fTagArr[10];
	_tagQueue<float> fQueue;

	for (int i = 0; i < 10; ++i)
	{
		iTagArr[i].m_data = i;
		fTagArr[i].m_data = (float)i * 0.1f;
		iQueue.Enqueue(&iTagArr[i]);
		fQueue.Enqueue(&fTagArr[i]);
	}

	for (int i = 0; i < 10; ++i)
		cout << iQueue.Dequeue()->m_data << endl;

	for (int i = 0; i < 10; ++i)
		cout << fQueue.Dequeue()->m_data << endl;

	system("pause");
	return 0;
}


저작자표시 (새창열림)

DeltaTime

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

QueryPerformanceFrequency(&g_tSecond);

QueryPerformanceCounter(&g_tTime);

.

.

.

.

.

QueryPerformanceCounter(&tTime);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////


QueryPerformanceFrequency : CPU 프로세서의 초당 클럭수

QueryPerformanceCounter : 부팅시부터 현재까지 CPU 클럭 동작 횟수.


자료형은 _int64이다.


프레임당 움직인 거리 =   1회 연산의 클럭 수  /  초당 클럭수

g_fDeltaTime = (tTime.QuadPart - g_tTime.QuadPart) / (float)g_tSecond.QuadPart;


ex) 360/3600일 경우 한번 연산 당 360클럭이 소요. 10번 연산하면 1초. (기본 속도의 출력은 10FPS)
fSpeed는 게임의 속도.
float fSpeed = 6 * g_fDeltaTime; (속도 적용 후 출력은 6*10  = 60FPS)


저작자표시 (새창열림)

가상소멸자 사용 이유

업캐스팅 후 지우면 자식만 없어진다. 그래서 가상 소멸자 사용.


함수 호출 규약

1. __cdecl : C/C++에서 사용하는 기본 규약 리턴 후 정리하기 떄문에 돌아올때도 가변인자 사용 가능. 하지만 소스가 길어짐

Add ESP, 8; 이후 더 진행. caller.

2. __stdcall : winAPI visualBasic에서 사용하는 기본 규약. 함수 리턴 후 가변인자 사용 불가능.

RETN 8;을 통해 ESP에 8을 더해주며 함수에서 빠져나옴, callee.

3. __fastcall : 주로 델파이에서 사용. 인자 전달시 2개까지는 ECX, EDX를 이용하여 함수의 인자를 받는다. 

즉, 레지스터를 이용하기 때문에 메모리를 사용하는 다른 함수호출 규약보다 더 빠르다. 마찬가지로 리턴 후 가변인자 사용 불가능.

RETN 4;를 통해 ESP에 4를 더해주며 함수에서 빠져나옴. callee.

저작자표시 (새창열림)

+ Recent posts

티스토리툴바