2023_12_13

조정우·2023년 12월 13일
cpp기맞

객체지향 프로그래밍 언어

-> "개념", "행동", "상태"로 인간의 욕구를 구분
ex)

  • 몬스터를 만들고 싶다 -> 개념
  • 몬스터는 움직여야 한다 -> 행동 -> 함수
  • 이동 속력 -> 상태 -> 변수
#include <iostream>

void MonsterMove()
{
	int MonsterSpeed = 4;
}

int main()	// 프로세스의 시작
{	// 지역 시작
	
    // 지역 변수
    int MonsterSpeed = 1;
    
    MOnsterMove();
}	// 지역 끝

변수 (Variable)

규칙

  1. 같은 이름의 변수는 같은 영역 안에 2번 선언할 수 없음
    -> 같은 이름의 변수는 메모리 영역이 겹치기 때문
  2. main 함수에 만들 수 있으면 다른 함수에도 만들 수 있음
  3. 영역이 다르면 같은 이름의 변수를 만들 수 있음
    -> 변수 앞에 생략된 이름이 다름
    -> 메모리에 저장되는 영역이 다름

지역 변수 (Local Variable)

  • {} 에 속하는 영역
    -> 함수가 실행되면 램에 지역 메모리를 만들고 그 안에 변수를 둔다.
  • 메모리의 스택 영역에 생성 (함수 영역 안에 생성)
  • 어떤 지역에서 만든 변수는 다른 지역에서 사용 불가능
    -> 함수 안에 만들어진 변수 (함수 내부의 변수)
    ex)
int main()
{
	int A = 10;	// 지역 변수
}

tip) 이름 없는 메모리 영역 만들기

int main()
{
	int Value = 0;
    
    // 이름 없는 메모리 영역
    {
    	Value = 10;
        int Value2 = 0;	// 된다
    }
    
    Value = 20;	// 안된다
}

전역 변수 (Global Variable)

  • {} 에 속하지 않는 영역
  • 메모리의 데이터 영역에 생성
  • 프로그램이 종료되기 전까지 메모리에 반환되지 않음
    ex)
int A = 10;	// 전역 변수

int main()
{
}

클래스 내부 지역

-> 클래스를 배우고 나서...

메모리 (Memory)

  • 메모리 구조

  • 메모리에서 프로그램

cf) 영역(Range, Scope) == 지역(Local)

스택 영역

  • 뒤에서 부터 생성
  1. 스택 영역에 main 영역(내부의 변수 + a)을 잡음 -> {을 만나면
  2. 스택 영역에 함수 영역(내부의 변수 + a)을 잡음 -> {을 만나면
  3. }을 만나면 영역 해제 (메모리 반환)

데이터 영역

  • 스택 영역이 만들어지기 전에 생성
  • 프로세스가 종료되기 전까지 파괴되지 않음
  • 전역 변수

코딩 스탠다드 (Coding Standard)

  • 표기법 및 구문법을 각 회사나 프로젝트 상황에 맞춰서 규칙을 정한 것
    -> 어기면 안된다

기맞 코딩 규칙 (Coding Standard)

  • 구글 코딩 스탠다드 + 언리얼
    1. 경로 및 함수 변수 절대 한글 금지
    2. 프로젝트 폴더 바탕화면에 금지
    3. 변수명은 FullName으로 작성
    4. 전역 변수와 지역 변수 이름은 다르게 작성
    5. 변수 생성시 무조건 리터럴 값(초기화)을 작성
    6. 함수의 인자 이름 앞에는 _를 붙임
    7. 암시적 형변환은 피하기
    8. 자료형이 다르면 정당한 캐스팅을 통해서만 형변환을 할 것
      -> C 스타일 형변환 하지 않음
    9. 포인터를 초기화 할때 0을 사용하지 않음 (nullptr 사용)

ex) 

int GlobalA = 10;	// 전역 변수

void Test()
{
	int LocalA = 10;	// 지역 변수
}

tip) 함수를 사용한 상태로 빌드 하는 것이 좋다 (함수를 만들고 사용을 안하면 Compiler에 의해 삭제 되고 실행될 수 있음)

코드 읽기 규칙

  1. 기본적으로는 위에서부터 애래로
  2. 오른쪽에서 왼쪽으로
  3. 예외 () 안에 있는 것이 먼저 실행
    ex)
    int main()
{
	int Left = 3;
   // 오른쪽에서 왼쪽으로 읽는다.
   // 1. 3을 준비
   // 2. 대입 연산자를 준비
   // 3. Left를 만든다.
   // 4. 대입한다.
}

연산자 (Operator)

-> 변수를 사용해서 특정한 결과를 반환하는 것
-> 연산자 == 함수 == 행동
-> 연산자는 무조건 같은 자료형끼리 구성
->> 다른 자료형일 경우 형변환이 일어날 수도 있음

종류
1. 산술 연산자
2. 비교 연산자
3. 관계 연산자
4. 비트 연산자
5. 복합 할당 연산자
6. 멤버와 포인트 연산자
7. 기타 연산자

1) 단항 연산자

  • 변수 1개 필요
    ex) !

2) 이항 연산자

  • 변수 2개 필요
    ex) +, ==, = - 등...

3) 삼항 연산자

  • 변수 3개 필요
    ex) ? :

cf) 변수의 사용방법
-> 앞에 자료형이 붙어있으면 만듬
-> 사용할 때는 자료형을 생략하고 사용

1. 산술 연산자

1) = (대입 연산자)

int main()
{
	int Left = 3;
    int Right = 5;
    
    Left = Right;
    // 오른쪽(Right)의 메모리를 왼쪽(Left)의 메모리로 복사
}

2) + (뎃셈)

int main()
{
	int Left = 3;
    int Right = 5;
    int Result = 0;
    
    Result = Left + Right;
}

3) - (뺄셈)

int main()
{
	int Left = 3;
    int Right = 5;
    int Result = 0;
    
    Result = Left - Right;
}

4) * (곱셈)

int main()
{
	int Left = 3;
    int Right = 5;
    int Result = 0;
    
    Result = Left * Right;
}

5) / (몫 연산자)

int main()
{
	int Left = 3;
    int Right = 5;
    int Result = 0;
    
    Result = Left / Right;
    // Left를 Right로 나눈 몫
}

6) % (나머지 연산자)

int main()
{
	int Left = 3;
    int Right = 5;
    int Result = 0;
    
    Result = Left % Right;
    // Left를 Right로 나눈 후 나머지
}

2. 비교 연산자

  • 논리형(bool) 리턴

1) == (값 같은지 비교)

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left == Right;
    // Left가 Right와 같은지 값 비교
    // 같으면 true
    // 다르면 false
}

2) != (값이 같지 않은지 비교)

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left == Right;
    // Left가 Right와 같은지 값 비교
    // 같으면 false
    // 다르면 true
}

3) >

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left > Right;
    // Left가 Right와 같은지 값 비교
    // 크면 true
    // 작으면 false
}

4) <

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left < Right;
    // Left가 Right와 같은지 값 비교
    // 크면 false
    // 작으면 true
}

5) >=

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left < Right;
    // Left가 Right와 같은지 값 비교
    // 크거나 같으면 true
    // 작으면 false
}

6) <=

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    Result = Left < Right;
    // Left가 Right와 같은지 값 비교
    // 작거나 같으면 true
    // 크면 false
}

3. 논리 연산자

  • 참과 거짓에 대해 이해해야 함

  • 비트 단위로 자료형을 바라볼 수 있어야 함

  • 참
    -> 모든 비트 중 단 1개라도 1이 있으면 참
    -> 0제외 모든 숫자는 참

int main()
{
	bool bResult = false;
    bResult = 3;	// true
}
  • 거짓
    -> 모든 비트가 0이면 거짓
    -> 0만 거짓
int main()
{
	bool bResult = false;
    bResult = 0;	// false
}

1) ! (논리 부정 = Not)

  • true -> false
  • false -> true
int main()
{
    bool bResult = false;
    
    bResult = !Result
    // false -> true
    // true -> false
}

2) && (논리 합 = AND)
-> 모든 메모리가 참이어야 참 리턴
-> true && true 일 경우에만 true
-> 나머지는 false

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    bResult = Left && Right;
    // true && ture => true
	bResult = false && Right;
    // false && ture => false
    bResult = Left && false;
    // true 8& flase => false
    bResult = false || false;
    // false && false => false
}

3) || (논리 곱 = OR)
-> 모든 메모리가 거짓이어야 거짓 리턴
-> false || false 일 경우에만 false
-> 나머지는 모드 true

int main()
{
	int Left = 3;
    int Right = 5;
    bool bResult = false;
    
    bResult = Left || Right;
    // true && ture => true
	bResult = false || Right;
    // false && ture => true
    bResult = Left || false;
    // true 8& flase => true
    bResult = false || false;
    // false || false => false
}

4. 비트 연산자

  • 정수의 비트 표현식
    -> ex) int => 4byte => 32bit

  • 비트
    -> 가장 앞 비트는 부호 비트

  • 0 : 양수
    -> 그냥 양수 표현식으로 계산
  • 1 : 음수
    -> 2의 보수법 적용
  • 2의 보수법
    ->> 음수로 만들 경우 모든 비트를 뒤집고 1을 더한 것
    ex) 1 = 0001 -> 모두 뒤집기 = 1110 -> 1 더하기 = 1111 -> -1
    ex) 2 = 0010 -> 모두 뒤집기 = 1101 -> 1 더하기 = 1110 -> -2

cf) 2의 보수 쉽게 적용하는 법
-> 양수 표현식에서 뒤집는다.
=> 모든 값이 1로 채워졌을 때를 -1로 본다.
=> 0인 부분의 숫자를 음수로 더해줌

  • C++ 버전을 바꿔서 진행

1) ~ (비트 Not)

  • 0비트 -> 1비트
  • 1비트 -> 0비트
int main()
{
    int Left = 0;
    int Right = 0;
    
    Left = 0b00000000000000000000000000000000;	// 0
   	Left = ~0b00000000000000000000000000000000; // -1
    // -> 0b11111111111111111111111111111111	// -1
}

2) & (비트 AND)
-> 왼쪽과 오른쪽을 비교해서 true true일 경우에만 true
-> 나머지는 false

int main()
{
    int Left = 0;
    int Right = 0;
    int Result = 0
    
    Left =  0b00000000000000000000000000000011;	// 3
   	Right = 0b00000000000000000000000000000001; // 1
    
    Result = Left & Right;
    // Left =   0b00000000000000000000000000000011;	// 3
   	// Right =  0b00000000000000000000000000000001; // 1
    // Result = 0b00000000000000000000000000000001; // 1
}

3) | (비트 OR)
-> 왼쪽과 오른쪽을 비교해서 하나라도 true일 경우에 true
-> 모두 false일 경우에만 false

int main()
{
    int Left = 0;
    int Right = 0;
    int Result = 0
    
    Left =  0b00000000000000000000000000000011;	// 3
   	Right = 0b00000000000000000000000000000001; // 1
    
    Result = Left | Right;
    // Left =   0b00000000000000000000000000000011;	// 3
   	// Right =  0b00000000000000000000000000000001; // 1
    // Result = 0b00000000000000000000000000000011; // 3
}

4) ^ (비트 XOR = 베타적 논리합)
-> 양쪽의 비트가 같으면 0
-> 양쪽의 비트가 다르면 1

int main()
{
    int Left = 0;
    int Right = 0;
    int Result = 0
    
    Left =  0b00000000000000000000000000000011;	// 3
   	Right = 0b00000000000000000000000000000001; // 1
    
    Result = Left ^ Right;
    // Left =   0b00000000000000000000000000000011;	// 3
   	// Right =  0b00000000000000000000000000000001; // 1
    // Result = 0b00000000000000000000000000000010; // 2
}

5) << (비트 시프트)
-> 비트를 왼쪽으로 밀어 넣음

int main()
{
    int Left = 0;
    int Result = 0
    
    Left =  0b00000000000000000000000000000001;	// 1
    
    Result = Left << 1;
    // Left =   0b00000000000000000000000000000001;	// 1
    // Result = 0b00000000000000000000000000000010; // 2
}

5) >> (비트 시프트)
-> 비트를 오른쪽으로 밀어 넣음
-> 밀어서 끝단까지 갈 정도로 사용하지 않음
->> 밀어서 끝단까지 가게되면? 하드웨어(CPU 칩셋)에 따라 달라짐
->>> 잘 사용하지 않음

int main()
{
    int Left = 0;
    int Result = 0
    
    Left =  0b00000000000000000000000000000001;	// 1
    
    Result = Left >> 1;
    // Left =   0b00000000000000000000000000000001;	// 1
    // Result = 0b00000000000000000000000000000000; // 2
}

5. 기타 연산자

1) sizeof()

#include <iostream>

int main()
{
	int Value = 0;
    int IntSize = 0;
    
    IntSize = sizeof(int);
    IntSize = sizeof(Value);
}

과제 (비트 연산을 활용하여 int 양수의 최대값 구하기)

#include <iostream>

int main()
{
	int Left = 0;
	int Right = 0;
	int Result = 0;

	// 양수 최대값 구하기
	// Left   = 0b11111111111111111111111111111111  -> -1
	//		    xor
	// Right  = 0b10000000000000000000000000000000  -> 음수 최대값
	// Result = 0b01111111111111111111111111111111  -> 양수 최대값

	Left = 0;
	Left = ~Left;	// -1
    Right = 1 << 31;	// 음수 최대값
	

	Result = Left ^ Right;	// 양수 최대값

	int Answer = 0b01111111111111111111111111111111;

	return 0;
}

자료형

Bool 자료형

  • 1Byte 논리형
  • 참, 거짓을 나타내는 자료형
  • true / false 존재

cf) 중단점 (빨간점)
-> 코드를 보다보면 중간단계 확인이나 현재까지 진행한 단계와 그 상태에서의 값을 확인하고 싶을 때 자신이 확인하고 싶은 코드 라인 1줄 아래에 F9를 누르면 중단점이 걸림

  • 노란색 화살표 = 실행 대기하고 있는 코드의 라인

tip) 단축키
F9 = 중단점 생성 및 삭제
F5 = 중단점이 있으면 중단점이 있는 곳 까지만 실행 후 멈춤
F10 = 코드 한 줄씩 진행 (다른 함수의 스택으로 들어가지는 않음)
F11 = 한줄 씩 진행하지만 다른 함수가 있다면 함수 내부 스택까지 들어감

tip) 필터 / 솔루션 폴더

  • 특정 프로젝트를 모아 놓고 싶을 때 사용
profile
조정우
게임 개발
이전 포스트

2023_12_12

다음 포스트

2023_12_14

0개의 댓글