2. 연산자, 전처리 구문 + 캐릭터 상태 설정

---

🟦 C++ 연산자 정리 표

 

연산자 종류	연산자	설명	예제
산술 연산자	+	덧셈	a + b
	-	뺄셈	a - b
	*	곱셈	a * b
	/	나눗셈	a / b
	%	나머지	a % b
대입 연산자	=	값 할당	a = b
	+=	덧셈 후 할당	a += b // a = a + b
	-=	뺄셈 후 할당	a -= b // a = a - b
	*=	곱셈 후 할당	a *= b // a = a * b
	/=	나눗셈 후 할당	a /= b // a = a / b
	%=	나머지 후 할당	a %= b // a = a % b
증감 연산자	++	1 증가	a++ 또는 ++a
	--	1 감소	a-- 또는 --a
비교 연산자	==	같음	a == b
	!=	다름	a != b
	<	작음	a < b
	>	큼	a > b
	<=	작거나 같음	a <= b
	>=	크거나 같음	a >= b
논리 연산자	&&	논리 AND	a && b
	||	논리 OR	a || b
	!	논리 NOT	!a
비트 연산자	&	비트 AND	a & b
	|	비트 OR	a | b
	^	비트 XOR	a ^ b
	~	비트 NOT	~a
	<<	비트 왼쪽 이동	a << b
	>>	비트 오른쪽 이동	a >> b
삼항 연산자	?:	조건문	x = (a > b) ? a : b;
멤버 접근 연산자	.	객체 멤버 접근	obj.var
	->	포인터 멤버 접근	ptr->var
포인터 연산자	*	포인터 역참조	*ptr
	&	주소 연산자	&var
형 변환 연산자	(type)	C 스타일 형 변환	(int)a
	static_cast<>	정적 형 변환	static_cast<int>(a)
	dynamic_cast<>	동적 형 변환	dynamic_cast<Derived*>(basePtr)
	const_cast<>	const 속성 제거	const_cast<char*>(str)
	reinterpret_cast<>	포인터 변환	reinterpret_cast<int*>(ptr)
기타 연산자	sizeof	크기 계산	sizeof(a)
	typeid	타입 정보 반환	typeid(a).name()
	,	쉼표 연산자	a = (b, c)
	new	동적 메모리 할당	int* p = new int;
	delete	동적 메모리 해제	delete p;
	new[]	배열 동적 할당	int* arr = new int[10];
	delete[]	배열 동적 해제	delete[] arr;

 

---

🟦 C++의 연산자 우선순위

우선순위	연산자	설명	결합 방향
1	::	범위 지정 연산자	왼쪽 → 오른쪽
2	() [] -> . ++ --	함수 호출, 배열, 멤버 접근, 후위 증가/감소	왼쪽 → 오른쪽
3	++ -- + - ! ~ * & sizeof new delete typeid	전위 연산자, 부호, 크기 연산 등	오른쪽 → 왼쪽
4	.* ->*	멤버 포인터 연산자	왼쪽 → 오른쪽
5	* / %	곱셈, 나눗셈, 나머지	왼쪽 → 오른쪽
6	+ -	덧셈, 뺄셈	왼쪽 → 오른쪽
7	<< >>	비트 시프트	왼쪽 → 오른쪽
8	< <= > >=	비교 연산자	왼쪽 → 오른쪽
9	== !=	동등성 비교	왼쪽 → 오른쪽
10	&	비트 AND	왼쪽 → 오른쪽
11	^	비트 XOR	왼쪽 → 오른쪽
12	|	비트OR	왼쪽 → 오른쪽
13	&&	논리 AND	왼쪽 → 오른쪽
14	||	논리OR	왼쪽 → 오른쪽
15	?:	삼항 조건 연산자	오른쪽 → 왼쪽
16	`= += -= *= /= %= &=	= ^= <<= >>=`	대입 연산자
17	throw	예외 처리	오른쪽 → 왼쪽
18	,	쉼표 연산자	왼쪽 → 오른쪽

 

---

 

🟦 세미콜론(;)의 역할

🔹 enter는 중요하지 않음. 세미콜론(;)이 구문의 끝을 알리는 역할을 함.
🔹 줄 바꿈 없이 여러 구문을 한 줄에 써도 ;로 구분됨.

int data = 10 + 10; // 20
data + 20; // 저장되지 않고 값만 계산됨
data = data + 20; // 40 (data += 20 과 동일)

 

---

🟦 나머지 연산자(%)

🔹 % 연산자는 정수형 피연산자에만 사용 가능.
🔹 실수형(double, float)에는 사용할 수 없으며, 컴파일 에러 발생.

int data = 10. / 3.; // 10 / 3으로 계산됨  
// 경고 발생: ‘double’에서 ‘int’로 변환하며 데이터 손실 가능  

int data = (int)(10. / 3.); // 명시적 형 변환 → 경고 없음

 

---

🟦 증감 연산자 (++, --)

🔹 특별한 이유가 없다면 전위(++data) 방식 사용 추천.
🔹 실수형에서는 1씩 증가/감소.
🔹 포인터 연산에서는 1칸(단계)씩 이동 (+는 왼쪽, -는 오른쪽).

전위	후위
++data	data++
가장 먼저 적용	가장 마지막에 적용 (대입 연산자보다 나중)

 

---

 

🟦 bool 자료형

🔹 true(1) / false(0) 값을 가지며, 엄밀히 따지면 정수 타입.
🔹 bool 변수에 0이 아닌 숫자를 대입하면 자동으로 1(true)로 변환.
🔹 1byte 크기이지만 0과 1만 저장 가능.

bool IsTrue = 100; // 1(true) 저장됨
IsTrue = !IsTrue;  // 0(false) 저장됨

 

---

🟦 제어문

🔹 if, else, switch case
🔹 switch case에서는 반드시 break를 사용해야 멈춤.
🔹 컴파일러 최적화 옵션을 활성화하면 실행될 수 없는 구문은 제거됨.
🔹 Debug 모드에서는 최적화가 적용되지 않음.

if (false) {
  data++; // 최적화 옵션 활성화 시, 이 구문은 컴파일러에서 제거됨
}

 

---

🟦 삼항 연산자 (? :)

🔹 if 문을 간단하게 표현 가능.

int max = (a > b) ? a : b;  // a가 크면 a, 그렇지 않으면 b를 저장

 

---

🟦 비트 연산자

🔹 비트 연산은 마스크 처리, 최적화된 데이터 저장, 암호화, 그래픽 프로그래밍 등에서 활용됨. 🚀

연산자	설명	예제
&	비트 AND	a & b
|	비트 OR	a|b
^	비트 XOR	a ^ b
~	비트 NOT	~a
<<	비트 왼쪽 이동	a << b
>>	비트 오른쪽 이동	a >> b

---

🟦 C++의 비트 시프트 (<<, >>)

🔹 << : 왼쪽 이동 (값이 2^n 배 증가)
🔹 >> : 오른쪽 이동 (값이 2^n 배 감소, 몫만 남고 나머지는 버려짐)

unsigned char byte = 10;  
byte <<= 3; // 10 * 2^3 = 80 (2진수로 변환 시 오른쪽에 0이 3개 추가됨)  
byte >>= 3; // 다시 3칸 오른쪽 이동하여 원래 값으로 복구됨  

int 변수 = a;
변수 <<= m;  // a * 2^m  
변수 >>= m;  // a / 2^m  (몫만 남음)  

 

---

🟦 주요 비트 연산자 활용 예제

1️⃣ 비트 AND (&)

🔹 특정 비트가 켜져 있는지 확인하거나, 특정 비트 끄기
🔹 두 비트가 모두 1일 때만 1이 됨

int a = 5;   // 0101  
int b = 3;   // 0011  
int c = a & b; // 0001 (1)  

// 특정 비트가 1인지 확인  
if (a & (1 << 2)) {  // 2번째 비트가 켜져 있는지 확인  
    std::cout << "2번째 비트가 1이다." << std::endl;
}

// 특정 비트 끄기  
a = a & ~(1 << 2);  // 2번째 비트 끄기  

---

 

2️⃣ 비트 OR (|)

🔹 특정 비트를 켜거나 값 합칠 때 사용
🔹 두 비트 중 하나라도 1이면 1이 됨

int a = 5;   // 0101  
int b = 3;   // 0011  
int c = a | b; // 0111 (7)  

// 특정 비트 켜기  
a = a | (1 << 2);  // 2번째 비트 켜기  

 

---

3️⃣ 비트 XOR (^)

🔹 특정 비트를 토글(반전)
🔹 두 비트가 다를 때 1이 됨

int a = 5;   // 0101  
int b = 3;   // 0011  
int c = a ^ b; // 0110 (6)  

// 특정 비트 토글  
a = a ^ (1 << 2);  // 2번째 비트 반전  

// XOR을 이용한 두 수 스왑 (임시 변수 없이 교환)  
int x = 5, y = 7;  
x = x ^ y;  
y = x ^ y;  
x = x ^ y;  

 

---

4️⃣ 비트 NOT (~)

🔹 모든 비트를 반전 (1 → 0, 0 → 1)

int a = 5;   // 0000 0101  
int c = ~a;  // 1111 1010 (2의 보수 표현으로 -6)  

// 특정 비트 마스크 만들기  
int mask = ~(1 << 3); // 3번째 비트만 0으로 만드는 마스크  

// 음수 값 계산 (2의 보수)  
int negativeA = ~a + 1; // a의 음수 값  

 

---

🟦 전처리 구문 (Preprocessing)

전처리 지시어	설명	예제
#define	매크로 정의	#define PI 3.14
#undef	매크로 해제	#undef PI
#include	헤더 파일 포함	#include <iostream>
#ifdef	특정 매크로가 정의되었을 때 코드 실행	#ifdef DEBUG
#ifndef	특정 매크로가 정의되지 않았을 때 코드 실행	#ifndef DEBUG
#if	조건부 컴파일	#if PI > 3
#else	#if, #ifdef, #ifndef가 거짓일 때 실행	#else
#elif	#else if와 유사, 조건부 컴파일	#elif VERSION == 2
#endif	조건부 컴파일 블록 종료	#endif
#pragma	컴파일러에 특정 지시 전달	#pragma once
#error	강제 컴파일 오류 발생	#error "Unsupported compiler"
#warning	경고 메시지 출력 (GCC, Clang 지원)	#warning "Deprecated feature"
##	토큰 결합 연산자 (Token Pasting)	#define CONCAT(a, b) a##b
#	문자열화 연산자 (Stringizing)	#define STR(x) #x

 

#define은 특정값을 치환한다.

#define 일치값 치환값

코드에 일치값이 있으면 모두 치환값을 넣은걸로 컴파일 됨

#define구문 사용하는 이유

 1. 가독성

  예시

  캐릭터의 특정 상태를 상수로 지정 및 사용

  배고픔 1

  아픔 27

  -> 코드에 ‘배고픔’이 있으면 1로 컴파일 되도록 함.

 2. 코드 유지보수가 쉬워짐

 

 

#include <stdio.h>



// 상태 정의 (비트 플래그 방식)

#define HUNGRY 0x01 // 배고픔 (0000 0001)

#define FULL 0x00 // 배부름 (명확한 상태 없음)

#define THIRSTY 0x02 // 목마름 (0000 0010)

#define HYDRATED 0x00 // 수분 충분 (명확한 상태 없음)

#define POISONED 0x04 // 중독됨 (0000 0100)

#define HEALTHY 0x00 // 건강함 (명확한 상태 없음)

#define IN_COMBAT 0x08 // 전투 중 (0000 1000)

#define STEALTH 0x10 // 은신 상태 (0001 0000)

#define EXHAUSTED 0x20 // 피로함 (0010 0000)

#define ENERGIZED 0x40 // 활력 충만 (0100 0000)

#define BLEEDING 0x80 // 출혈 상태 (1000 0000)

#define INFECTED 0x100 // 감염됨 (0001 0000 0000)



int main()

{

unsigned int state = 0; // 초기 상태: 아무 상태도 없음



// 1. 상태 추가 (| 연산자 사용)

state |= HUNGRY; // 배고픔 추가

state |= THIRSTY; // 목마름 추가

printf("현재 상태: %X\n", state);



// 2. 상태 제거 (& 연산자 사용)

state &= ~HUNGRY; // 배고픔 제거

printf("배고픔 제거 후 상태: %X\n", state);



// 3. 특정 상태 확인 (& 연산자 사용)

if (state & THIRSTY) {

printf("목마른 상태입니다.\n");

}



// 4. 여러 상태가 존재하는지 확인 (& 연산자 사용)

if ((state & (THIRSTY | POISONED)) == (THIRSTY | POISONED)) {

printf("목마르고 중독된 상태입니다.\n");

}

else {

printf("목마르거나 중독되지 않은 상태입니다.\n");

}



// 5. 상태가 존재하지 않는지 확인 (!= 연산자 사용)

if (!(state & POISONED)) {

printf("중독되지 않았습니다.\n");

}



// 6. 상태를 토글하기 (^ 연산자 사용)

state ^= IN_COMBAT; // 전투 상태 토글 (켜거나 끄기)

printf("전투 상태 토글 후: %X\n", state);



// 7. 여러 상태 설정 (| 연산자 사용)

state |= (POISONED | BLEEDING); // 중독 + 출혈 추가

printf("중독 및 출혈 추가 후 상태: %X\n", state);



return 0;

}

 

 

캐릭터의 상태를 지정할 때 사용할 수 있는 단어 예시

1. 기본적인 신체 상태

건강(HEALTHY) / 아픔(INJURED, SICK)

배고픔(HUNGRY) / 배부름(FULL)

목마름(THIRSTY) / 수분충분(HYDRATED)

졸림(SLEEPY, DROWSY) / 각성(ALERT, AWAKE)

피로(FATIGUED, EXHAUSTED) / 활력(VIGOROUS, ENERGETIC)

기절(FAINTED, UNCONSCIOUS) / 정신차림(CONSCIOUS, AWARE)

출혈(BLEEDING) / 출혈 없음(STABLE)

골절(BROKEN BONE) / 정상(NORMAL)

 

2. 정신 상태

정신이 또렷함(FOCUSED, CLEAR-MINDED) / 혼란(CONFUSED, DISORIENTED)

기분 좋음(HAPPY, CHEERFUL) / 우울(DEPRESSED, SAD)

공포(FEARFUL, PANICKED) / 침착(CALM, RELAXED)

분노(ANGRY, ENRAGED) / 평온(PEACEFUL, CONTENT)

스트레스 받음(STRESSED, ANXIOUS) / 무덤덤(INDIFFERENT, CAREFREE)

광기(MAD, INSANE) / 제정신(SANE, STABLE)

집중(FOCUSED) / 산만(DISTRACTED)

 

 

3. 생존 및 환경 영향

더위(HOT, OVERHEATED) / 추위(COLD, FREEZING)

중독(POISONED, INTOXICATED) / 중독 없음(CLEAN, DETOXED)

감염(INFECTED) / 면역(IMMUNE, CLEAN)

방사능 오염(RADIATED) / 방사능 없음(NOT RADIATED)

익사 중(DROWNING) / 호흡 가능(BREATHING, SAFE)

탈진(EXHAUSTED) / 회복됨(RESTED, RECOVERED)

어둠 속(DARKNESS, BLINDED) / 밝음 속(IN LIGHT, VISIBLE)

 

 

4. 전투 및 행동 관련

전투 중(IN COMBAT, ENGAGED) / 전투 종료(OUT OF COMBAT, PEACEFUL)

스텔스 상태(STEALTH, HIDDEN) / 발각됨(DETECTED, VISIBLE)

무장(DISARMED, UNARMED) / 무기 장착(ARMED, READY)

기절(STUNNED, KNOCKED OUT) / 활동 가능(ACTIVE, ALERT)

속박됨(RESTRAINED, GRAPPLED) / 자유(FREE, MOBILE)

저지됨(STAGGERED, INTERRUPTED) / 행동 가능(UNSTOPPED, UNHINDERED)

기회 타이밍(OPPORTUNE, ADVANTAGEOUS) / 불리한 상태(DISADVANTAGED, VULNERABLE)

 

 

5. 기타 상태

버프(ENHANCED, BUFFED) / 디버프(DEBUFFED, WEAKENED)

축복받음(BLESSED) / 저주받음(CURSED)

광폭화(BERSERK, RAGING) / 냉정(COOL-HEADED)

도움받음(AIDED, ASSISTED) / 고립됨(ISOLATED, ALONE)

시간 느림(SLOWED, SLUGGISH) / 시간 빠름(HASTED, QUICKENED)

 

 

활용 예시

비트마스크 방식으로 상태를 정의할 경우:

#define HUNGRY 1 // 00000001

#define FULL 2 // 00000010

#define THIRSTY 4 // 00000100

#define HYDRATED 8 // 00001000

#define POISONED 16 // 00010000

#define HEALTHY 32 // 00100000

#define IN_COMBAT 64 // 01000000

#define STEALTH 128 // 10000000

 

 

 

비트 플래그 방식 외에 상태 정의 방법.

1. 비트 플래그 방식 (Bit Flags)

여러 상태를 동시에 저장할 수 있음 (비트 연산 활용).

메모리를 절약할 수 있고, 빠른 연산이 가능.

복잡한 상태 관리가 필요할 때 적합.

#include <stdio.h>
// 상태 정의 (비트 플래그 방식)
#define HUNGRY 0x01 // 0000 0001
#define THIRSTY 0x02 // 0000 0010
#define POISONED 0x04 // 0000 0100
#define IN_COMBAT 0x08 // 0000 1000

int main() {
	unsigned int state = 0; // 초기 상태 (아무 상태도 없음)

	// 상태 추가
	state |= HUNGRY | THIRSTY;
	printf("현재 상태: %X\n", state);

	// 상태 제거
	state &= ~HUNGRY;
	printf("배고픔 제거 후 상태: %X\n", state);

	// 상태 확인
	if (state & THIRSTY) {
		printf("목마른 상태입니다.\n");
	}

	return 0;
}

✅ 사용 상황:

게임 캐릭터의 다양한 상태를 효율적으로 관리할 때

메모리를 절약하면서 여러 상태를 동시에 관리할 때

 

 

2. 열거형 방식 (Enum)

상태를 열거형으로 정의하여 가독성이 좋음.

단일 상태 관리에 적합 (복합 상태에는 적합하지 않음).

#include <stdio.h>
// 열거형으로 상태 정의
typedef enum {
	STATE_HUNGRY,
	STATE_THIRSTY,
	STATE_POISONED,
	STATE_IN_COMBAT
} CharacterState;

int main() {
	CharacterState state = STATE_HUNGRY; // 초기 상태: 배고픔

	// 상태 변경
	state = STATE_THIRSTY;
	printf("현재 상태: %d\n", state);

	// 상태 확인
	if (state == STATE_THIRSTY) {
		printf("목마른 상태입니다.\n");
	}

	return 0;
}

 

✅ 사용 상황:

한 번에 하나의 상태만 유지해야 하는 경우

코드 가독성을 높이고 싶을 때

 

3. 구조체 방식 (Struct)

여러 상태 값을 개별 변수로 저장할 수 있음.

관리가 쉬우나, 메모리 사용이 많아질 수 있음.

#include <stdio.h>
// 구조체로 상태 정의
typedef struct {
	int isHungry;
	int isThirsty;
	int isPoisoned;
	int isInCombat;
} Character;

int main() {
	Character player = { 1, 0, 0, 1 }; // 배고픔, 전투 중

	// 상태 확인
	if (player.isHungry) {
		printf("배고픈 상태입니다.\n");
	}

	// 상태 변경
	player.isHungry = 0;
	printf("배고픔 제거\n");

	return 0;
}

✅ 사용 상황:

상태가 많고, 각 상태를 독립적으로 관리해야 할 때

개별 상태의 값을 조정해야 할 때

 

4. 배열 방식 (Array/Set)

상태를 배열 또는 집합(Set) 형태로 저장.

특정 상태를 쉽게 추가/제거 가능.

검색 연산이 필요하므로 속도가 상대적으로 느릴 수 있음.

#include <stdio.h>
#include <string.h>

#define MAX_STATES 10

const char* STATES[] = { "HUNGRY", "THIRSTY", "POISONED", "IN_COMBAT" };

// 상태 리스트 관리
typedef struct {
    char states[MAX_STATES][20]; // 각 상태 문자열을 저장할 배열
    int count;
} StateList;

// 상태 추가
void addState(StateList* list, const char* state) {
    if (list->count < MAX_STATES) {
        strcpy(list->states[list->count], state);
        list->count++;
    }
}

// 상태 출력
void printStates(StateList* list) {
    printf("현재 상태: ");
    for (int i = 0; i < list->count; i++) {
        printf("%s ", list->states[i]);
    }
    printf("\n");
}

int main() {
    StateList player;
    memset(&player, 0, sizeof(StateList));  // 구조체 전체를 0으로 초기화

    addState(&player, "HUNGRY");
    addState(&player, "IN_COMBAT");

    printStates(&player);

    return 0;
}

 

✅ 사용 상황:

동적으로 변하는 상태를 관리해야 할 때

특정 상태를 쉽게 추가/삭제해야 할 때

 

 

🔍 비교 요약

방식	장점	단점	사용 예시
비트 플래그	빠르고 메모리 절약	해석이 어려움	게임 캐릭터 상태 관리
열거형 (Enum)	가독성이 좋음	여러 상태 동시 관리 어려움	단일 상태 변경이 필요한 경우
구조체 (Struct)	개별 변수로 관리 가능	메모리 사용 증가	상태별 세부 조정 필요할 때
배열/집합 (Array/Set)	상태 추가/삭제 유연	검색 시 속도 저하 가능	가변적인 상태 관리