Gyong

레퍼런스 자료형

-> C++부터 등장한 자료형

-> 원본 데이터에 접근하는 두 번째 방법이다.

-> 첫 번째 방법으로는 포인터를 통한 간접 참조를 이용하고,

-> 두 번째 방법으로는 레퍼런스를 통한 직접 참조를 이용한다.

레퍼런스의 형태

레퍼런스로  한번 참조한 메모리는 변경이 불가능하다.

-> 선언과 동시에 초기화를 진행해야만 한다.

자료형& 변수명
int a = 10;
int& r = a;

레퍼런스를 이용한 swap

void Swap(int& _a, int& _b)
{
	int itemp = 0;
	itemp = _a;
	_a = _b;
	_b = itemp;	
}

void main()
{
	int a = 10, b = 20;
	Swap(a, b);
	cout << a << " , " << b << endl;
}

const와 레퍼런스

-> 컴퓨터가 변수를 다룰 때는 단순히 자료형만 보고 판단한다.

const int a = 10;

const int   a = 10;
int&	    r = a;

r의 자료형은 일반 레퍼런스이다.

-> r을 통해서 값 변경을 한다.

-> 하지만, 참조하고 있는 공간은 값 변경이 불가능한 const 변수이다.

int& r = 20; // 불가능

20은 리터럴 상수이므로 임시 메모리 영역이 등록이 된다.

(코드라인을 벗어나면 소멸하는 공간)

문법 이론상 성립하지 않는다.

하지만, C++에서는 성립할 수 있도록 "임시 변수"를 생성해준다.

임시 변수란 "이름 없이 메모리 공간에 등록되는 변수"이다.

const int& r = 20;	// 가능

이것을 통해서 값 변경을 시도해보자.

void Add(const int& _a, const int& _b)
{
	int iRes = _a + _b;

	cout << iRes << endl;

}

void main()
{
	Add(10, 20);
}

레퍼런스의 크기

-> 레퍼런스 변수를 만들기 위해 공간을 할당하지 않는다.

-> 즉, 레퍼런스의 크기는 존재하지 않는다.

파일 분할

-> 구현한 기능이 많아지고 코드라인이 길어지면 프로젝트 관리가 힘들어진다.

-> 관리하기 편하게 하기 위하여 파일을 분리하여 관리하는 것이 좋다.

-> 파일 이름은 대소문자까지 포함해서 반드시 클래스 이름과 일치해야 한다.

-> 여러 파일이 하나의 클래스를 이룰 때, 파일 이름은 클래스 이름으로 시작하고,

-> 그 뒤에 밑줄과 세부 항목 이름을 붙인다.

class TextRPG;

TextRPG_Load.cpp
TextRPG_Save.cpp

#1. 헤더 파일

-> 어떤 종류의 기능들이 있는지 알려주는 역할.

-> 함수의 선언부, 구조체, 열거체 등을 모아 놓는 곳

#2. 소스 파일

-> 헤더 파일에 선언한 것들의 정의부를 모아 놓은 곳

컴파일은 파일 단위로 진행하기 때문에 해당 파일에서 필요한 정보들은 모두 include를 해줘야한다.

예)

#include "xxxx.h"

외부 헤더 파일을 인클루드 할 때는 #include<> 을 사용.

자체적으로 만든 헤더 파일을 인클루드 할 때는 위에 처럼  #include "" 를 사용한다.

외부 헤더 파일(표준 템플릿)을 먼저 인클루드한 뒤,

자체적으로 만든 헤더 파일을 인클루드 한다.

include를 할 때는, 가능하다면 알파벳 순서를 따르는 것이 좋다.(a -> b -> c 순)

파일 분할 시 문제점

-> 다양한 파일들을 만들고 엮는 과정에서 무한 참조 현상이 발생할 수 있다.

-> 이를 해결하기 위해서는 include를 1회만 할 수 있도록 조절해야 한다.

문제해결 방법

#1. #pragma once

-> 한번 읽어가면 추가적으로 읽지 않도록하는 기능

-> 헤더 파일 최상단에 #pragma once를 명시하면 해결된다.

-> 표준이 아니므로 작동하지 않을 수 있다.

#2. 조건부 컴파일

-> #ifndef ~ #endif + #define

예)

#ifndef ABCD
#define ABCD

// 헤더파일의 기능 작성

#endif

파일 분할 시 주의 사항

#1. 컴파일은 파일 단위로 진행하기 때문에 필요한 헤더들은 모두 포함해주어야 한다.

#2. 헤더 파일에 전역 변수를 선언할 수 없다.

#3. 헤더 파일에는 특정한 경우를 제외한 함수의 정의부를 두어선 안된다.

조건부 컴파일
-> 컴파일을 하는데 조건을 두어 컴파일 할지, 말지를 결정한다.

사용자가 값을 입력하여 컴파일 여부를 결정할 수 없다.
-> 값을 입력하는 시점은 컴파일이 모두 완료된 런타임 시점

(전역 변수나 지역 변수를 통해 비교 불가능)
-> 컴파일 이전에 조건을 비교해야 하기 때문에 전처리기 단계에서 조건을 비교한다.

##1. #if ~ #endif
-> if문을 사용하듯이 사용하면 된다.
-> 조건이 참일 경우 컴파일을 수행한다.

if       -> #if

else if -> #elif

else    -> #else

#define TEST 1

void main()
{
#if TEST > 0
 cout << "TEST는 0보다 크다." << endl;
#endif
}

#if는 기존 if와는 다르게 시작 구간과 종료 구간이 {}안이 아닌 #if를 선언한 시점부터 #endif 이전까지이다.

그래서 #if를 끝내려면 마지막에 #endif를 적어줘야한다.

#2 조건부 컴파일 #ifdef

-> define으로 정의되어 있다면 컴파일을 수행

#define ABCD

void main()
{
#ifdef ABCD
  cout << "ABCD는 정의되어 있음" << endl;
#endif
}

#3 조건부 컴파일_#ifndef ~ #endif

-> ifdef의 반대 의미이다.

-> define으로 정의되어 있지 않다면 수행

-> 주로 사용하는 방법은 1회만 수행하길 원할 때 사용한다.

#define ABCD

void main()
{
#ifndef ABCD
  cout << "ABCD는 정의되어 있지 않음" << endl;
#endif
}

매크로

-> 단순 치환

-> #define으로 정의한다.

# : 전처리 지시자

-> 컴파일 이전에 수행

define : 정의하다.

-> 컴파일 이전에 정의하라고 명령.

#1 매크로 상수

#define 매크로이름 치환할 값

매크로 상수 사용 시 주의사항

-> 단순 치환이기 때문에 세미콜론을 작성할 경우 세미콜론까지 치환해버린다.

예)

#define PI 3.14f;

// 입력
cout << PI << endl; 

// 출력
cout << 3.14f; << endl;

매크로 이름 뒤에 치환할 값이 없다면 공백으로 처리한다.

예)

#define PI 

// 입력
cout << PI << endl; 

// 출력
cout <<  << endl;

#define 매크로는 주로 배열의 크기를 다룰 때 사용을 한다.

#define MAX_SIZE 512

void main()
{
  int iArr[MAX_SIZE] = {};
}

#2 매크로 함수

-> 매크로를 함수처럼 사용하는 것

#define 매크로이름()  정의부 구현
#define SQUARE(n) n * n

이것은 다음 함수와 같다.

int Square(int _n)
{
  return _n *_n;
}

일반 함수 호출

-> 함수가 위치한 호출 번지로 이동 -> Stack 영역 할당 및 매개 변수 복사

-> 연산 -> 값 반환 및 Stack 영역 정리 -> 호출했던 위치로 복귀

매크로 함수 호출

-> Stack 영역이 할당 및 복사가 없다.

-> 속도가 빠르다.

-> 함수 호출을 위한 연산들이 필요 없어진다.

매크로 함수의 주의점

#1 연산을 수행할 때 연산자 우선순위를 명확하게 표시해야한다.

예)

#define SQUARE(n) n * n
cout << SQUARE(2 + 2) << endl;		// cout << 2 + 2 * 2 + 2 << endl;

이렇게 되면 연산자 우선순위가 곱셈을 먼저 수행해서 2 * 2 + 2 + 2 = 8이 된다.

하지만 다음과 같이 #define 함수를 정의할 때 우선순위를 정해주면 원하는 값이 나오게 된다.

#define SQUARE(n) (n) * (n)
cout << SQUARE(2 + 2) << endl;		// cout << (2 + 2) * (2 + 2) << endl;

#2 함수의 정의부가 길 경우
-> 매크로 함수는 줄 바꿈을 할 수 없다.
-> 무조건 1줄로만 매크로로 인식한다. 
-> 이를 해결하기 위해 줄바꿈 전에 \(역슬러쉬)로 다음 줄에도 매크로 이어진다. 라고 알려주어야 한다.

#define SQUARE(n) \
n * n

-> 단, \ 뒤에 공백 문자가 올 경우 컴파일 오류가 발생한다!

#define SQUARE(n) \공백
n * n

#3 디버깅이 불가능하다

-> 매크로 함수는 짧지만 자주 사용하는 함수를 매크로 함수로 정의하는 것이 좋다.

예를 들어 포인터 할당을 해제하는 경우가 생겼을 때

if(p != nullptr)
{
  delete p;
  p = nullptr;
}

다음과 같이 매크로를 지정하여 손쉽게 할당 해제가 가능하다.

#define SAFE_DELETE(p) if(p) { delete p; p = nullptr; }

함수()
{
코드 블럭
SAFE_DELETE(포인터 값);
}

#define 으로 정의된 상수는 항상 괄호로 감싸준다.

#define NUM (1)

상수는 #define 보다 const 상수 변수로 선언한다.