검은수달의 논두렁 굴 도서관 - Backotter's Ricefields Library

실행 화면

플레이 화면

소리가 엄청 크니, 실행할 때는 전체 음량을 줄인 상태로 실행해보시길 바랍니다.

실행 파일 이름은 testN.exe 입니다.

- 주저리 -

3년 전 쯤에 만들었던 거라... 어찌 했는지 기억 조차 나지 않는 흑역사 중 하나, 하도 버그가 많아서 조심을 해야하는 것이긴 하지만, 그래도 C/C++ 가지고로도 게임이랍시고 하나가 나온다는 걸 증명하는

흑역사라 버리기가 아까웠다.

너구리 게임.zip

namespace. 글쓴이나, C++을 공부하는 사람들이나 상당히 생소한 개념이다.

근데 사용법이나, 개념은 어렵지 않다.

네임스페이스(namespace)를 풀어서 말하면 '이름을 붙여놓은 공간' 이라고 할 수 있다.

- namespace의 기본원리 -

한 아파트에 철수라는 이름의 사람이 두 명이 산다면, 상황에 따라서 문제가 될 수 있다.

그냥 '철수야' 라고 부르면, 어떤 철수를 부르는지 알 수 가 없다. 아파트가 다르면 문제될 것이 없지만

이와 같은 상황이라면 다를 것이다. 그러면 어떻게 해야할까?

아파트에는 '호실'이라는 단위로 집이 있다. 101호, 102호 이렇게 말이다.

101호와 102호에 각각 철수가 살고 있다면, 다음과 같이 부르면 각 철수를 구분할 수 있다.

'102호에 사는 철수야'

이것이 namespace의 기본원리이다.

아래 코드를 보며 네임스페이스(namespace)의 사용법과 동작을 보자.

- namespace1.cpp -

#include <iostream>

using namespace std;

namespace BestComImpl

{

void SimpleFunc(void)

{

cout << "BestCom이 정의한 함수" << endl;

}

}

namespace ProgComImpl

{

void SimpleFunc(void)

{

cout << "ProgCom이 정의한 함수" << endl;

}

}

int main(void)

{

BestComImpl::SimpleFunc();

ProgComImpl::SimpleFunc();

return 0;

}

실행화면

위에 사용된 연산자 :: 가리켜 범위지정 연산자 라 하며, 그 이름이 의미하듯이 이름공간을 지정할 떄 사용하는 지정할 때 사용하는 연산자이다.

일반적으로 함수는 선언과 정의를 분리하는 것이 일반적이다. 아래 코드를 통해 

네임스페이스(namespace) 기반에서 함수의 선언과 정의를 구분하는 법을 보도록 하자.

- namespace2.cpp -

#include <iostream>

using namespace std;

namespace BestComImpl

{

void SimpleFunc(void);

}

namespace ProgComImpl

{

void SimpleFunc(void);

}

int main(void)

{

BestComImpl::SimpleFunc();

ProgComImpl::SimpleFunc();

return 0;

}

void BestComImpl::SimpleFunc(void)

{

cout << "BestCom이 정의한 함수" << endl;

}

void ProgComImpl::SimpleFunc(void)

{

cout << "ProgCom이 정의한 함수" << endl;

}

실행화면

네임스페이스(namespace)의 또 다른 예시 코드를 소개하며 이번 글을 마치겠다. 네임스페이스(namespace)에 관한 내용은 추가적으로 다시 이어 나가도록 하겠다.

- namespace3.cpp -

#include <iostream>

using namespace std;

namespace BestComImpl

{

void SimpleFunc(void);

}

namespace BestComImpl

{

void PrettyFunc(void);

}

namespace ProgComImpl

{

void SimpleFunc(void);

}

int main(void)

{

BestComImpl::SimpleFunc();

return 0;

}

void BestComImpl::SimpleFunc(void)

{

cout << "BestCom이 정의한 함수" << endl;

PrettyFunc();

ProgComImpl::SimpleFunc();

}

void BestComImpl::PrettyFunc(void)

{

cout << "So Pretty!!" << endl;

}

void ProgComImpl::SimpleFunc(void)

{

cout << "ProgCom이 정의한 함수" << endl;

}

실행결과

C언어에는 매크로 함수라는 기능이 있다.

매크로 함수의 대표적인 장점은 "일반적인 함수에 비해서 실행속도의 이점이 있다" 이다.

단점으로는 "정의하기가 어렵다. 복잡한 함수를 매크로 형태로 정의하는데 한계가 있다" 이다.

C++언어에는 이러한 매크로 함수의 장점은 유지를 하되 단점은 제거한 기능이 있다.

바로 인라인(Inline) 함수 이다. 코드를 보자.

- InlineFuce1.cpp -

#include <iostream>

using namespace std;

inline int SQUARE(int x)

{

return x*x;

}

int main(void)

{

cout << SQUARE(5) << endl;

cout << SQUARE(12) << endl;

return 0;

}

실행화면

이러한 인라인 함수도 매크로 함수의 장점을 완전히 대체하지 못하였다.

그것은 데이터의 손실 이다. 예를 보면서 설명 하겠다.

#define SQUARE(x) ((x)*(x))

cout << SQUARE(12);    int형 함수호출

cout << SQUARE(3.15);  duble형 함수호출

위와 같이 실행을 하면 다음과 같이 변환이 이뤄져서

어떠한 경우에도 데이터의 손실이 발생하지 않는다.

cout << ((12)*(12));       int형 함수호출

cout << ((3.15)*(3.15));  duble형 함수호출

하지만 다음과 같이 정의된 인라인 함수의 경우에는...

inline int SQUARE(int x) { return x*x }

int형 기반으로 정의된 함수이기 때문에 다음의 함수호출 문장에서 데이터 손실이 발생한다.

cout << SQUARE(3.15); //0.15가 손실되어서 3 X 3의 결과인 9가 출력!

이러한 문제를 해결하기 위해서 C++의 템플릿이라는 것을 이용하면 매크로 함수와 마찬가지로 자료형에 의존적이지 않는 함수가 완성된다. 템플릿은 이후에 서적을 참고하여 이후 글에서 다시 소개하겠다.

대신 서적에 있는 간단한 예시를 통해 맛을 보자.

#inlcude <iostream>

using namespace std;

template <typename T>

inline T SQUARE(T x)

{

return x*x;

}

int main(void)

{

cout << SQUARE(5.5) << endl;

cout << SQUARE(12) << endl;

return 0;

}

위 코드를 실행해보면 데이터 손실이 없는 것을 볼 수 있다.

C++에서는 디폴트 값이라는 것을 설정할 수 있다. 여기서 말하는 디폴트 값이란 기본적으로 설정되어 있는 값을 의미한다. 아래 각 예제 코드들을 가지고 해보길 바란다. 본론으로 들어가겠다.

- DefaultValue1.cpp -

#include <iostream>

using namespace std;

int Adder(int num1 = 1, int num2 = 2) // Adder함수의 인자값의 디폴트 값이 1, 2로 설정되어 있다.

{

return num1 + num2;

}

int main(void)

{

cout << Adder() << endl;

cout << Adder(5) << endl;

cout << Adder(3, 5) << endl;

return 0;

}

실행결과

- DefaultValue2.cpp -

#include <iostream>

using namespace std;

int Adder(int num1 = 1, int num2 = 2);

// Adder함수의 선언부 인자값의 디폴트 값이 1, 2로 설정되어 있다.

int main(void)

{

cout << Adder() << endl;

cout << Adder(5) << endl;

cout << Adder(3, 5) << endl;

return 0;

}

int Adder(int num1, int num2)

{

return num1 + num2;

}

실행결과

- DefaultValue3.cpp -

#include <iostream>

using namespace std;

int BoxVolume(int length, int width = 1, int height = 1);

int main(void)

{

cout << "[3, 3, 3] : " << BoxVolume(3, 3, 3) << endl;

cout << "[5, 5, D] : " << BoxVolume(5, 5) << endl;

cout << "[7, D, D] : " << BoxVolume(7) << endl;

// cout << "[D, D, D] : " << BoxVolume() << endl;

return 0;

}

int BoxVolume(int length, int width, int height)

{

return length*width*height;

}

실행화면

- 문제 -

다음과 같은 형태로의 함수 오버로딩은 문제가 있다. 어떠한 문제가 있는지 설명해보자

int SimpleFunc(int a = 10)

{

return a + 1;

}

int SimpleFunc(void)

{

return 10;

}

해답(아래 빈부분을 드래그하면 보입니다.)

함수를 호출할 때 인자값을 전달하지 않고 함수를 호출하는 경우. 두 함수 모두 호출조건을 만족하기 때문에 컴파일 에러가 발생한다.

#include <iostream>

#include <list>

using namespace std;

//사용할 구조체.

struct Temps

{

int a;

int b;

};

void main()

{

list<Temps> mylist;//리스트 변수.

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

{

Temps s;//임시 사용할 구조체 변수.

s.a = i * 10;//구조체 내부 변수값 수정.

mylist.push_back(s);//리스트 변수에 삽입.

}

list<Temps>::iterator iter = mylist.begin();

  //반복자 생성 및 리스트 변수의 처음 위치값을 연결해준다.

while (iter != mylist.end())//반복자가 리스트의 끝을 만날때까지 계속 반복한다.

{

Temps a = *iter;//반복자 변수 주소값을 넘긴다.

cout << a.a << endl;//화면에 출력

iter++;//반복자 주소값 쉬프트.

}

}

C++에서는 함수 오버로딩이라는 기법이 허용되는데, 이 기법은 의외로 자주 쓰인다.

일단 어떻게 쓰는지 코드를 먼저 보기로 하자.

#include <iostream>

using namespace std;

void MyFunc(void)

{

cout << "MyFunc(void) called" << endl;

}

void MyFunc(char c)

{

cout << "MyFunc(char c) called" << endl;

}

void MyFunc(int a, int b)

{

cout << "MyFunc(int a, int b) called" << endl;

}

int main(void)

{

MyFunc();

MyFunc('A');

MyFunc(12, 13);

return 0;

}

- 출력 -

MyFunc(void) called

MyFunc(char c) called

MyFunc(int a, int b) called

#include <iostream>

#include <map>

using namespace std;

struct Temps

{

int a;

};

void main()

{

map<int, int> m;//앞은 키 / 뒤는 값

//밑의 두 방식은 결과가 같다.

m.insert(pair<int, int>(5, 10));

m.insert(pair<int, int>(15, 20));

pair<int, int> p(22, 33);

m.insert(p);

//

m[50] = 105;

cout << m[50] << endl << m[5] << endl;

map<char*, int> k;//앞은 키 / 뒤는 값

//밑의 두 방식은 결과가 같다.

k.insert(pair<char*, int>("a", 10));

k.insert(pair<char*, int>("bcde", 20));

pair<char*, int> l("t", 33);

k.insert(l);

k["tt"] = 105;

// k.insert(pair<char*, int>("tt", 106));//이렇게 하면 뒤에 값이 안쓰여지지만, 

// k["tt"] = 106;//이렇게 하면 뒤에 값이 그대로 쓰인다.

map<char*, int>::iterator iter = k.find("tt");

cout << iter->first << " : " << iter->second << endl;

iter = k.begin();

while (iter != k.end())

{

int v = iter->second;

cout << v << endl;

iter++;

}

//

}

FP F_Create(char* fileName, FT* pOpentype)

{

int type = 0x8000;

FP file_point;

if (pOpentype == "b")

type = 0x8000;

else if (pOpentype == "t")

type = 0x4000;

file_point = _open(fileName, _O_CREAT | _O_TRUNC | type, S_IWRITE);

if (file_point == -1)

{

cout << "파일을 생성할 수 없거나, 이미 파일이 존재합니다.\n";

return NULL;

}

return file_point;

}

FP Open(char* fileName, char* pOpentype)

{

int type = 0x8000;

FP file_point;

if (pOpentype == "b")

type = 0x8000;

else if (pOpentype == "t")

type = 0x4000;

file_point = _open(fileName, _O_RDWR | type);

if (file_point == -1)

{

cout << "파일이 없거나, 열 수가 없습니다.\n";

return NULL;

}

return file_point;

}

FP Write(FP file_point, BYTE* buffer, size_t nBufferSize)

{

if (file_point == -1)

{

cout << "파일이 없거나, 쓸 수가 없습니다.\n";

return NULL;

}

_write(file_point, buffer, nBufferSize);

return file_point;

}

BYTE* Read(FP file_point, BYTE* buffer, size_t nBufferSize)

{

int length = 0;

if (file_point == -1)

{

cout << "파일이 없거나, 읽을 수가 없습니다.\n";

_close(file_point);

return NULL;

}

length = _read(file_point, buffer, nBufferSize);

if (length == 0)

{

cout << "파일에 저장된 내용이 없습니다..\n";

return NULL;

}

buffer[length] = '\0';

return buffer;

}

void Close(FP file_point)

{

_close(file_point);

}

#include <iostream>

using namespace std;

void Print(int val);

void Print(float val);

void Pos(int n);

void cat();

void dog();

int Sum(int a, int b);

typedef void (*PF)();

void main()

{

// Print(10);

// Print(101.2f);

// Pos(10);

int k = 0;

PF P;

void(*p)();

void(*pa)(int);

void(*pk)(float);

p = &cat;

(*p)();

p = &dog;

(*p)();

pa = &Print;

(*pa)(55);

k = Sum(10, 20);

cout << k << endl;

system("pause");

}

void Print(int val)

{

cout << val << endl;

}

void Print(float val)

{

cout << val << endl;

}

void Pos(int n)

{

cout << n << "\n";

if (n < 1)

return;

Pos(n - 1);

cout << n << "\n";

}

void cat()

{

cout << "고냥\n";

}

void dog()

{

cout << "개\n";

}

int Sum(int a, int b)

{

int c = b + c;

return c;

}

#include "Cnumber.h"

Cnumber::Cnumber()

{

m_nNumber = 0;

}

Cnumber::Cnumber(int n)

{

m_nNumber = n;

}

Cnumber operator+(int n, const Cnumber& num)

{

return num.m_nNumber + n;

}

//--------------------------------------------------------------

Cnumber Cnumber::operator+(Cnumber num)

{

Cnumber result;

result.m_nNumber = this->m_nNumber + num.m_nNumber;

return result;

}

Cnumber Cnumber::operator-(Cnumber num)

{

Cnumber result;

result.m_nNumber = this->m_nNumber - num.m_nNumber;

return result;

}

Cnumber Cnumber::operator*(Cnumber num)

{

Cnumber result;

result.m_nNumber = this->m_nNumber * num.m_nNumber;

return result;

}

Cnumber Cnumber::operator/(Cnumber num)

{

Cnumber result;

result.m_nNumber = this->m_nNumber / num.m_nNumber;

return result;

}

//--------------------------------------------------------------

Cnumber Cnumber::operator=(const Cnumber& num)

{

this->m_nNumber = num.m_nNumber;

return *this;

}

//--------------------------------------------------------------

bool Cnumber::operator==(const Cnumber& num)

{

return this->m_nNumber == num.m_nNumber;

}

bool Cnumber::operator!=(const Cnumber& num)

{

return this->m_nNumber != num.m_nNumber;

}

bool Cnumber::operator<(const Cnumber& num)

{

return this->m_nNumber < num.m_nNumber;

}

bool Cnumber::operator>(const Cnumber& num)

{

return this->m_nNumber > num.m_nNumber;

}

bool Cnumber::operator<=(const Cnumber& num)

{

return this->m_nNumber <= num.m_nNumber;

}

bool Cnumber::operator>=(const Cnumber& num)

{

return this->m_nNumber >= num.m_nNumber;

}

//--------------------------------------------------------------

Cnumber Cnumber::operator++()

{

return this->m_nNumber++;

}

Cnumber Cnumber::operator--()

{

return this->m_nNumber--;

}

//--------------------------------------------------------------

Cnumber Cnumber::operator+=(const Cnumber& num)

{

return this->m_nNumber += num.m_nNumber;

}

Cnumber Cnumber::operator-=(const Cnumber& num)

{

return this->m_nNumber -= num.m_nNumber;

}

Cnumber Cnumber::operator*=(const Cnumber& num)

{

return this->m_nNumber *= num.m_nNumber;

}

Cnumber Cnumber::operator/=(const Cnumber& num)

{

return this->m_nNumber /= num.m_nNumber;

}

//--------------------------------------------------------------

void Cnumber::Print()

{

cout << m_nNumber << endl;

}

Cnumber::~Cnumber()

{

}