: 명령어 집합 구조(Instruction Set Architecture, ISA) : CPU가 해석하는 명령어의 집합

✔️ 마이크로 아키텍쳐

: how to implement an architecture in hardware : CPU의 하드웨어적 설계 : ISA를 효율적으로 처리할 수 있도록 CPU의 회로를 설계하는 분야

⭐️ 아키텍쳐 : programmer’s view of computer : Defined by instructions & operand locations

✔️ 마이크로프로세서

: 제어장치, 연산장치, 레지스터가 하나의 대규목 집적회로 (IC칩)에 내장된 것 : 개인용 컴퓨터(PC)에서 중앙처리장치로 사용

설계 방식에 따라 RISC, CISC로 구분(참고)

1. RISC(reduced instruction set computer)

• 장점 : 명령어의 개수가 적어 처리 속도가 빠름
• 단점 : 명령어의 개수가 적기 때문에 레지스터가 많고 프로그래밍이 복잡함
• 쓰임새 : 전력 소모가 적고 처리 속도가 빨라야 하는 곳 (보통 스마트폰 또는 임베디드 기기)

2. CISC(complicated instruction set computer)

• 장점 : 명령어의 개수가 많아 레지스터가 적고 프로그래밍이 RISC의 비해 쉬움
• 단점 : 명령어의 개수가 많아 처리 속도가 느림
• 쓰임새 : 고사양 작업을 필요로 하는 곳 (보통 개인용 PC)

[CPU 아키텍처]

✔️ 종류

: x86, AMD64(x86-64), ARM, MIPS, AVR 등 : 컴퓨터마다 필요한 연산 능력과 컴퓨팅 환경이 다르기 때문에 다양한 ISA가 개발되고 사용됨

1. ARM

: RISC : Developed in the 1980’s by Advanced RISC Machines – now called ARM Holdings : '32-bit architecture'라고도 부름

• 16개의 레지스터를 가지고 있음

• 레지스터는 메모리보다 더 빠름

• 각 레지스터는 32비트

2011년에 출시된 ARMv8-A 아키텍처는 새로운 32비트 고정 길이 명령어 세트로 64비트 주소 공간과 64비트 산술에 대한 지원을 추가함. 보통 ARM AArch64라고 불림

[Arm Register Set]

2. x86

: intel에서 개발 : CISC

📌 Architecture Design Principles

CPU 아키텍처는 단순히 성능만을 고려해서 만드는 것이 아니라, 설계 시 다음과 같은 원칙들을 기반으로 만들어진다.

1. 규칙성은 설계를 단순하게 만든다 (Regularity supports design simplicity) • 명령어 형식이 일관되고, 항상 같은 개수의 오퍼랜드(피연산자)를 사용하면 하드웨어 설계가 쉬워진다.

   ARM 아키텍처의 명령어는 대부분 2개의 소스 + 1개의 목적지 구조로 고정되어 있음

   덧셈: ADD R0, R1, R2 (R1 + R2 → R0)

2. 자주 쓰이는 경우를 빠르게 처리하라 (Make the common case fast) • 일상적으로 많이 쓰이는 연산(예: 덧셈, 조건 분기 등)은 하드웨어에서 빠르게 실행되도록 최적화하고, 드물게 쓰이는 복잡한 명령은 단순한 명령들의 조합으로 처리한다.

   ARM은 복잡한 문자열 처리 명령은 따로 없지만,

   기본적인 load/store, branch, add 명령어만으로도 대부분의 프로그램을 구현할 수 있음

   드물게 쓰이는 기능은 소프트웨어나 명령어 조합으로 구현.

3. 작을수록 빠르다 (Smaller is faster) • 레지스터, 캐시, 회로 등은 작을수록 접근 시간이 짧고 속도도 빨라진다.

   ARM은 필요한 최소한의 레지스터(예: 16개)만 제공하여 하드웨어를 작고 효율적으로 유지

   전력 소모도 줄고, 모바일 환경에 적합함.

4. 좋은 설계는 좋은 타협에서 나온다 (Good design demands good compromises) • 단순성과 성능, 유연성과 전력 소비 등 여러 요소 간의 균형을 잘 맞추는 것이 중요하다.

ARM은 처리 속도와 전력 효율 사이에서 최적의 균형을 맞추기 위해 복잡한 명령은 줄이고, 하드웨어를 간소화함

: 명령어를 실행하기 위해 필요한 데이터와 상태, 명령어를 저장하는 기억 소자 : CPU 내부에 존재하며, 기억 장치 중 가장 빠르며 용량이 작음 : 데이터 레지스터와 제어용 레지스터로 구분

✔️ 데이터 레지스터

: CPU가 명령어를 처리하는 과정에서 임시로 처리할 데이터를 저장하거나 메모리의 주소를 저장할 목적으로 사용 : 데이터 레지스터(Data Register), 주소 레지스터(Address Register), 범용 레지스터(General Register)로 구분

1) 주소 레지스터

(1) 스택 포인터(SP, Stack Pointer) : CPU는 현재 실행하고 있는 프로그램의 메모리 영역을 스택으로 관리 : SP는 현재 스택 영역에서 가장 마지막 부분(가장 최근에 저장된)을 가르킴

(2) 베이스 포인터(BP, Base Potiner) : BP는 스택 영역에서 각 메모리 영역의 경계선을 가르킴 : 즉, 서브루틴 호출 시에 Caller의 SP는 BP가 됨 : 서브루틴의 실행이 완료되면 BP는 다시 SP가 됨

(3) 인덱스 레지스터(IX, Index Register) : 배열에 순차적으로 접근하기 위한 레지스터

✔️ 제어용 레지스터

: CPU가 프로그램의 실행 흐름을 제어하거나 상태를 저장하기 위해 사용되는 레지스터

1) 프로그램 카운터(PC, Program Counter)

: 다음에 실행할 명령어의 주소 저장

2) 명령어 레지스터(IR, Instruction Register)

: 현재 실행중인 명령어 저장

3) 메모리 주소 레지스터(MAR, Memory Address Register)

: 액세스할 메모리의 주소 저장 : 주소 버스에 연결

4) 메모리 버퍼 레지스터(MBR, Memory Buffer Register)

: 메모리에 접근 시에 해당 주소에 저장/적재할 데이터를 임시 저장 : 데이터 버스에 연결

5) 상태 레지스터(SR, Status Register)

: 조건 혹은 이벤트를 검사해 프로그램의 흐름을 제어 : 각 비트에 플래그 값을 가짐

(1) 조건 플래그(Conditional Flags) : 연산 결과를 나타냄

• 부호 플래그(S) : 산술 연산 결과의 부호비트 저장
• 제로 플래그(Z) : 연산 결과가 0인지 표시
• 자리 올림수 플래그(C) : 자리 올림수 발생 시 표시
• 패리티 비트(P) : 패리티 체크를 통해 연산 결과의 유효성 체크
• 오버플로우(OV) : 오버플로우 발생 여부

(2) 제어 플래그(Control Flags) : CPU를 제어하기 위한 것

• 인터럽트 플래그(IE) : CPU가 외부 인터럽트의 요청을 수락할지에 대한 여부
• 관리자 모드 플래그(SV) : 해당 명령어가 관리자 모드에서 실행되고 있는지에 대한 여부

: 2진 기수법 표기의 기본 단위 / 2진 숫자 : 2진 기수법에서의 모든 수는 0과 1로 표기하는데, 이 0 또는 1이 각각 하나의 비트가 됨

• msb: most significant bit
• lsb: least significant bit

📌 Byte

: 정보량의 최소 단위인 bit(0과 1)의 집합으로 구성된 기본 단위 : 컴퓨터에 의한 데이터 처리, 저장, 전송의 기본적인 단위로 많이 사용됨

8bit = 1byte

• MSB (Most Significant Byte)
• LSB (Least Significant Byte)
• 각 hex digit은 한 개의 nibble을 나타냄 (4 bits)

📌 Nibble

: 1바이트의 절반, 즉 4비트를 하나의 단위로 한 것

4 bit = 1 nibble

📌 Binary Coded Decimal (BCD)

: 십진수를 위한 가장 간단하고 직관적인 이진 코드 : 이진수와 동일한 2의 거듭제곱을 사용하지만 0에서 9까지 처음 10개의 값만 인코딩 함

• BCD 코드 : 8, 4, 2, 1 코드 ex) 1001 (9) = 1000 (8) + 0001 (1)

십진수를 이진수로 변환(conversion)하는 것과 코딩(coding)하는 것은 다름!! • conversion : 1310 = 11012 • coding : 13 <-> 0001|0011

📌 Hexadecimal Numbers

• 16진수를 2진수로 변환 (Hexadecimal to binary conversion)

  $$4AF_{16}$$ ( = 0x4AF) = 0100 1010 $$1111_{2}$$

• 16진수를 10진수로 변환 (Hexadecimal to decimal conversion)

  $$4AF_{16}$$ (0x4AF) = – 4 × $$16^2$$ + A × $$16^1$$ + F × $$16^0$$ – 4 × $$16^2$$ + 10 × $$16^1$$ + 15 × $$16^0$$ = $$1199_{10}$$

: 기억,해석,연산,제어라는 4대 주요 기능을 하는 컴퓨터의 가장 핵심적인 중앙 처리 장치

✔️ 구성 요소

1. ALU(Arithmetic Logic Unit) : 각종 산술 연산과 논리 연산을 수행하는 회로들로 이루어진 하드웨어 모듈 : 가산기, 보수기, 누산기, 기억 레지스터, 데이터 레지스터 등으로 구성
2. Control Unit : 컴퓨터의 제어를 담당하며 IODevice, Memory, ALU등의 동작을 제어 : 구현 방식으로 고정 배선제어(Hardwired), Micro Program 방식이 있음
3. Register set : 내부에 위치한 기억 장치 : CPU에서 Memory로 이동하는 시간을 단축해 빠르게 데이터를 처리할 수 있게 해주는 장치

<레지스터의 종류> 더 자세한 내용 : 레지스터(Register) -> PC(Program Counter) : 다음 실행할 명령어 주소를 가리키는 레지스터 -> IR(Instruction Register) : 현재 수행 중에 있는 명령어 부호를 저장하고 있는 레지스터 -> 누산기(ACC, Accumulator) : 데이터 일시 보관 레지스터 / 산술 및 논리 연산의 결과를 임시로 기억하는 레지스터 -> MAR(Memory Address Register) : CPU가 메모리 참조하기 위해 보관하는 데이터 주소를 가진 레지스터 -> MBR(Memory Buffer Register) : CPU가 메모리로부터 읽거나 저장 할 데이터 자체를 보관하는 레지스터

✔️ 명령어 수행 과정

: CPU 가 하나의 명령(Operation)을 처리하는 과정

1. 읽기(Fetch Instruction, FI)

• 실행할 명령어를 메모리에서 읽어 CPU로 가져옴

  PC가 가리키는 주소 → MAR MAR에 적힌 주소를 메모리(Memory)에서 읽어 → MBR MBR에 있는 명령어 → IR 저장 다음 명령어를 가리키도록 PC 주소값 증가

2. 해석(Decode Instruction, DI)

• IR에 저장된 인출한 명령어를 해석을 해서 해당 명령어에 포함된 데이터를 가져오고 이 명령어(ex.10h)를 해독하는 과정
• 여기서 "인출한 명령어에 포함된 데이터를 가져온다" 를 CPU 명령어 구조로 파악하자면

• 실제로 메모리에는 명령어 메모리, 주소 메모리를 따로 가지고 있지는 않음. 그냥 하나의 메모리에 명령어와 필요한 주소 데이터, 즉 인자(Argument)를 작성 해놓음 (= 기본적으로 하나의 명령은 opcode + argument(operand) 구조)

• 그러면 실제로 이 부분은 아래 빨간 네모 박스처럼 RAM(메모리)에 저장되어 있음
• 위 그림에서 LOD A라는 명렁과 01h라는 주소가 00111110(OpCode)와 00000001(Operand, argument)처럼 2진수로 표현될 것임
• 이것을 16진수로 표현하면 3E, 01로 표현되며, RAM에 순차적으로 저장되어 있음

3. 실행(Execute Instruction, EI)

• 명령어 실행
• MBR의 데이터와 ACC(Accumulator)의 데이터로 연산 후, ACC(Accumulator)에 저장

4. 기록(Write Back, WB)

• 실행 결과를 저장

✔️ 명령어 처리 방식

1. CISC (Complex Instruction Set Computer)

: 하나의 기능에 해당하는 하나의 명령이 있는 개념

• 여러 사이클로 명령어를 처리
• 많은 명령어가 메모리를 참조하는 처리 방식
• 파이프라이닝의 사용이 어려움
• 복잡한 마이크로 프로그램 구조를 갖고 있음

RISC (Reduced Instruction Set Computer)

: 컴퓨터 내부적으로 사용하는 명령어 세트를 단순화 시켜서 처리하는 형태의 구조 : 단순한 명령을 조합해서 하나의 기능을 수행

• 하나의 사이클로 명령어를 처리
• 메모리 Load / Store 명령만 처리하는 방식
• 파이프라이닝, 슈퍼스칼라의 사용이 가능
• 복잡한 컴파일러 구조를 갖고 있음

📌 메모리

: 기억장치로서 컴퓨터에서 데이터를 일시적으로 또는 영구적으로 보존하는 장치

✔️ 종류

: 주 기억 장치(RAM, ROM) 와 보조 기억장치(HDD SSD)

⭐️ 주 기억 장치 (RAM, ROM)

1. RAM

   1) SRAM (Static RAM)

   • CPU 안에 포함되어 캐시 메모리라고도 함

   • CPU와 DRAM의 속도 차이를 극복하기 위해 CPU와 DRAM 사이에 존재하는 고속 기억 장치

   • 캐시 메모리 : 시간적, 공간적 지역성을 기반으로 가까운 미래에 접근될 확률이 높은 데이터를 미리 보관하는 것

   • 전기가 남아있는 한 재생을 하지 않아도 메모리가 날아가지 않음

   • 2) DRAM (Dynamic RAM)*

   • 흔히 말하는 메인메모리

   • SRAM보다 속도는 느리지만 집적도를 높이기 쉬워 메모리 용량이 크고 SRAM보다 상대적으로 저렴

   • 축전기(capacitor)로 이루어져있는 소자의 집합체

     • 각각의 축전기가 담고 있는 전자의 수에 따라 전기신호를 1과 0으로 나타내는데, 축전기가 시간이 지나면 방전되기 때문에 일정 시간마다 재충전하여 데이터를 재생시켜야 함

   • 메모리 자체에 지속적인 전기를 소모하고, 전기가 약해지면 순간적으로 데이터가 날아감

2. ROM

• 메인보드에 작은 부품으로, 내용을 읽을 수는 있어도 쓰기가 불가능한 메모리
• 비휘발성 메모리
• 공장에서 생산될 때 납땜되어 출하되기 때문에, 입출력을 처리하는 바이오스 등의 변경 가능성이 없는 소프트웨어를 기억시키는데 사용

⭐️ 보조 기억 장치 (SSD, HDD)

1. SSD

• 플래시 메모리(SSD, USB)
• 데이터를 영구적으로 저장하는 비휘발성 대용량 기억장치
• 물리적인 디스크를 고속으로 회전시켜 데이터를 저장하는 장치
• 디스크에 물리적으로 저장하기 때문에 충격에 약하며, 소음이 발생

2. HDD

• 자기 디스크(HDD, FDD)
• 반도체를 이용하여 데이터를 저장하는 기억장치
• HDD와 다르게 전기적으로 데이터를 저장하기 때문에 속도도 월등히 빠르고 소음 발생 X
• 가격은 좀 높지만, 전력 소모도 적고 소형화가 가능하여 최근에 많이 사용되고 있는 보조기억장치

📌 IO

• Input/Output의 약자로 컴퓨터에게 있어 인간의 오감과 같은 역할을 함
  • Input : 마우스, 키보드, 카메라 등
  • Output : 모니터, 스피커, 프린터 등
  • In/Out : 네트워크, 저장매체 등
• CPU, 메모리 등 요소간에 Bus를 통해서 연결됨
  • But, 병목현상이 일어날 수 있는 문제점에 최근엔 고속 시리얼 통신을 이용하기도 함

📌 Bus

• 시스템 내외부 모듈 사이에 데이터 전송을 위한 통신 링크 규약
• 병렬 직렬 연결 모두 가능

✔️ 장점 & 단점

- 장점

• 새로운 노드 추가가 용이
• 표준 규격의 범용성과 낮은 연결 비용

  - 단점

• 통신 병목 현상 발생

📌 폰노이만 구조 VS 하버드 구조

✔️ 폰노이만 구조

: 존 폰노이만이 제시한 컴퓨터 구조 / 프로그램 내장 방식 : 현대 컴퓨터 구조의 기반이 된 컴퓨터 구조로, CPU, 메모리, 프로그램 구조를 확립 : CPU => fetch - decode - execute - store 순서로 처리

⭐️ 구성

• processing unit :
  • ALU(Arithmetic Logic Unit) : 산술/논리 연산 장치
  • processor registers
• control unit :
  • instruction register : 현재 실행중인 명령어 저장
  • program counter : 다음 실행할 명령어의 주소를 가리킴
• memory : 물리적 구분이 없어 같은 메모리, 버스를 사용 (동시 접근 X)
  • 데이터
  • 명령어 (프로그램)
• External mass storage : ex) SSD
• Input and output mechanisms

⭐️ 장점 & 단점

• 장점

  • 컴퓨터에 다른 작업을 시키려고 할 때 전처럼 하드웨어를 재배치할 필요 없이 소프트웨어만 교체 (범용성 향상)
  • 순차처리 방식은 수치 계산이나 정밀하게 작성된 프로그램을 실행하는 데에 탁월

• 단점

  • 하나의 버스로 메모리에 접근하기 때문에 CPU가 명령어와 데이터에 동시 접근 X (파이프라이닝 시에 구조적 해저드 문제)
  • 메모리 값을 읽고 쓰는 구조이기 때문에 기억장치에 병목현상 생김
  • 이미지나 소리와 같은 아날로그 데이터를 처리하는 데에 효율성이 낮음

🔥 폰 노이만 병목현상 (Von-Neumann Bottleneck)

: 기억장치의 속도가 전체 시스템의 성능 저하를 야기하는 현상 : 계산을 빠르게 처리할 수 있어도 기억을 불러오는 속도가 느리면 전체적으로 속도가 느려짐 (계산 속도가 기억장치 속도에 영향을 받음)

• 원인 :
  • 프로그램 메모리와 데이터 메모리가 물리적 구분 없이 하나의 버스를 통해 CPU와 교류
  • CPU는 명령어와 데이터에 동시 접근이 불가하며 나열된 명령을 한 번에 하나씩 읽고 씀

✔️ 하버드 구조

: 폰 노이만 병목현상을 해결하기 위한 컴퓨터 구조 : CPU가 명령어와 데이터를 동시에 사용할 수 있도록 명령용 버스와 데이터용 버스를 물리적으로 구분

⭐️ 장점 & 단점

• 장점
  • 프로그램의 명령어와 데이터를 동시에 접근할 수 있도록 지원함으로써 엑세스 속도 개선
  • 현재 명령의 처리를 끝냄과 동시에 다음 명령을 읽어 들여 더 빠른 속도를 냄
• 단점
  • 더 많은 전기 회로 필요

✔️ 현대 컴퓨터 구조

: CPU의 외부적으로는 폰 노이만 구조, 내부적으로는 하버드 구조를 적용하여 속도를 향상시킨 구조를 주로 사용 : 폰 노이만 구조를 기반으로 만들어진 것이기 때문에 병목현상만 어느 정도 해결할 뿐 메모리 속의 프로그램을 순차적을 실행하는 기본적인 구조 자체는 변하지 않음

참고 :

• 컴퓨터의 구조는 어떻게 생겼을까? 폰 노이만 구조

1. Window > Package Manager > Localization Package 다운
2. Project Setting > Localization 들어간 후, Setting 생성 (Localization Folder 따로 만들고 저장)
3. Project Setting > Locale Generator > 필요한 Language 선택 (Language 묶음 하나를 'LOCALE'이라 부름)
4. Specific Locale Selector / Project Locale Identifier 에 LOCALE 할당 (할당한 언어 : Defualt Language)

📌 다국어 자료 입력

1. Window > Asset Management > Localization Table
2. New table Collection > String Table Collection > Name 작성 및 생성 (Table : 다국어 자료 입력하는 DB / Tables 파일 만들고 저장해두기!)
3. Key 만들고 각 언어별 Text 작성

📌 다국어 설정 적용

1. 원하는 Text에 'Localize String Event' 컴포넌트 추가
2. String Reference에 생성한 Table 할당

📌 사용 방법

⭐️ 게임설정 UI에서 적용

• LocalizationSettings.AvailableLocales.Locales[index]

• Index 값을 받아 사용자가 지정한 언어로 변경

• Index 값의 순서는 Tables 창에서 표시되는 언어의 순서대로 지정하면 되며, 시작은 0번부터

using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

public void UserLocalization(int index) {
    LocalizationSettings.SelectedLocale = 
        LocalizationSettings.AvailableLocales.Locales[index];
}

⭐️ 동적으로 적용

예시 : 상점내 아이템 정보

1. Localize String Event Component만 추가해 주고 String Reference는 설정하지 않음

아래와 같이 아이템의 데이터가 다음과 같다면 Item 테이블을 만든 다음 Key 값으로 ItemName을 넣어줌

public class Item : ScriptableObject {
    public string itemID;
    public string itemName;
    public Sprite itemImage;
}

이후, 'LocalizeItem' 스크립트 생성후 다음과 같이 코드 작성 -> string tableName : 바로 위에서 만들어 두었던 Item 내용의 번역이 들어가 있는 Table명 -> Item itemValue : Table에서 key 값으로 사용될 itemName을 받음 -> 입력받은 Table 명과 Table의 key 값을 찾아 Localize String Event의 String Reference에 적용시켜 줌

using UnityEngine;
using UnityEngine.Localization.Components;

public class LocalizeItem : MonoBehaviour {
    public void LocalizeTextString(string tableName, Item itemValue) {
        GetComponent<LocalizeStringEvent>().StringReference
            .SetReference(tableName, itemValue.itemName);
    }
}

Item과 관련된 스크립트에서 위에서 작성한 스크립트의 함수를 가져와 적용시켜줌

public class ItemCard : MonoBehaviour {
    [Header("Localize Text")] 
    public LocalizeItem localizeTitle;

    Item item;

    void Start() {
        localizeTitle.LocalizeTextString("Item", item.itemName);
    }
}

참고 링크 :

• 유니티 (Unity) - 게임에 다중 언어 (Localization) 적용하기

개요

평소 개발을 진행하면서 프레임워크와 라이브러리를 많이 사용하는데, 이 둘의 차이점을 잘 알지 못하고 있었다. 이에 인터넷으로 여러 사람들의 블로그 내용을 정리하면서 둘의 차이점을 확실하게 알고자 글을 작성하게 되었다.

📌 프레임워크

: 원하는 기능 구현에 집중하여 개발할 수 있도록 일정한 형태와 필요한 기능을 갖추고 있는 골격, 뼈대 : 앱/서버 등의 구동, 메모리관리, 이벤트 루프 등 공통된 부분은 프레임워크가 관리하고, 사용자는 프레임워크가 정해준 방식대로 클래스, 메소드를 구현

• 자유도 : 낮음
• 거의 모든 기능을 제공

⭐️ 기능

1. 코드 재사용성 : 공통 기능을 제공하여 코드 재사용에 용이
2. 일정한 구조 제공 : 애플리케이션의 구조를 정의하여 개발자가 그 구조를 따르도록 함
3. 모듈화 : 기능을 모듈화하여 독립적인 컴포넌트로 나눌 수 있게 함
4. 생산성 향상 : 반복적인 작업을 자동화하고 개발 생산성을 높임
5. 유지보수성 : 일관된 코드 구조를 유지하여 유지보수성을 향상

⭐️ 종류

• Java 서버 개발 : Spring
• Python 서버 개발 : Django, Flask
• 안드로이드 앱 개발 : Android
• 아이폰 앱 개발 : Cocoa Touch
• 웹 개발 : Angular, Vue.js 등
• Java 기반의 JSP : Struts
• 루비로 작성된 MVC패턴을 이용 : Ruby on Rails

📌 라이브러리

: 소프트웨어를 개발할 때 컴퓨터 프로그램이 사용하는 비휘발성 자원의 모임 : 특정 기능을 모와둔 코드, 함수들의 집합이며 코드 작성 시 활용 가능한 도구 : 미리 작성된 코드, 변수, 함수, 클래스가 포함된다.

• 자유도 : 높음
• 기본 기능 외 제공 X

⭐️ 기능

1. 코드 재사용성: 특정 작업을 처리하는 코드의 재사용을 촉진
2. 추상화: 복잡한 작업을 간단한 함수 호출로 추상화
3. 모듈화: 기능별로 모듈화되어 필요에 따라 가져다 쓸 수 있음
4. 유연성: 개발자가 필요에 따라 라이브러리를 선택하여 사용할 수 있음

⭐️ 종류

• TensorFlow: 머신러닝과 딥러닝을 위한 Python 라이브러리
• Pandas: 데이터 분석과 조작을 위한 Python 라이브러리
• NumPy: 수치 계산을 위한 Python 라이브러리
• jQuery: HTML 문서 탐색 및 조작, 이벤트 처리, 애니메이션, Ajax를 쉽게 처리할 수 있게 하는 JavaScript 라이브러리
• Lodash: JavaScript 유틸리티 라이브러리로서 배열, 객체, 문자열 등 다양한 작업을 편리하게 처리할 수 있게 해

✔️ 프레임워크 vs 라이브러리

🌱 프레임워크

• 주도권 : 프레임워크

• 프레임워크가 제공하는 기능을 이용하거나 허용하는 범위 내에서만 추가 도구 사용 가능

• 프레임워크는 모델하우스를 짓는것에 비유할 수 있다. 모델하우스의 소파의 위치, 의자와 책상의 위치, 방의 용도 등. 우리가 수정할 수 있는 범위는 제한적이다. 주방의 위치, 기둥의 개수, 방의 개수 등 집을 이루고있는 굵직한 뼈대는 수정할 수 없다. 사용자는 모델하우스가 제공하는 청사진 안에서"만" 움직일 수 있다. 프레임워크가 제공하는 틀에 따라 코드를 작성해야 하는것이다.

🌱 라이브러리

• 주도권 : 개발자

• 기능 구현을 원하는 방향으로 진행

• 쓰고싶은 도구, 쓰고싶은 기술 사용

• 라이브러리는 이케아에서 산 재료로 가구를 조립하는것에 비유할 수 있다. 집에서 사용할 가구를 조립하거나 만들기 위해 벌목부터 시작해서 목공을 하거나, 가죽을 얻기위해 사냥을 하고싶은 사람은 거의 없을것이다. 그래서 이케아 혹은 가구점에 가서 기본적인 재료를 사서 입맛대로 조립하고 배치할 수 있다.

[ 토비의 스프링 中 ]

• 프레임워크는 단지 미리 만들어준 반제품이나, 확장해서 사용할 수 있도록 준비된 추상 라이브러리의 집합이 아니다. 프레임워크가 어떤 것인지 이해하려면 라이브러리와 프레임워크가 어떻게 다른지 알아야 한다.
• 라이브러리를 사용하는 애플리케이션 코드는 애플리케이션 흐름을 직접 제어한다. 단지 동작하는 중에 필요한 기능이 있을 때 능동적으로 라이브러리를 사용할 뿐이다.
• 프레임워크는 거꾸로 애플리케이션 코드가 프레임워크에 의해 사용된다. 프레임워크에는 분명한 [제어의 역전] 개념이 적용되어 있어야 한다.
• 애플리케이션 코드는 프레임워크가 짜 놓은 틀에서 수동적으로 동작해야 한다.

❗️ 정리

공통점

• 코드 작성에 도움이 되는 타인이 작성한 코드의 집합

  차이점

• 어플리케이션의 Flow(흐름)를 누가 가지고 있는가

• 프레임워크

  • 프로그램이 필요한것을 개발자에게 알려줌으로써 제어권을 역전
  • 전체적인 흐름을 프레임워크가 쥐고 있으며 사용자는 그 안에 필요한 코드를 짜 넣으면 됨 (틀안에 제어 흐름에 대한 주도성 내포)
  • 전체 어플리케이션의 구조를 정의하여 일정한 개발 패턴을 따르게 함

• 라이브러리

  • 개발자가 필요할 때 마다 설치, 혹은 호출함으로써 개발자가 능동적으로 사용
  • 사용자가 전체적인 흐름을 직접 만들고 필요에 따라 라이브러리를 가져다 씀 (사용자가 전적으로 제어 흐름에 대한 주도성 가짐)
  • 특정 기능만을 제공할 뿐 어플리케이션의 전체 구조에는 관여하지 않음 (개발자 스스로 원하는 방식으로 구조 설계 가능)

참고 링크 :

• 테드의 테크 블로그
• 프레임워크 vs 라이브러리
• [개발상식] 프레임워크(Framework)와 라이브러리(Library)의 차이

• 사용 : 선언(declaration)과 정의(definition)

1. 지역변수(Local variable)

: 함수 내부에서 선언되며 해당 함수가 호출되어 실행되면 생성되었다가 함수가 종료되면 사라지는 변수 : 해당 범위 내에서만 사용 가능하며 다른 함수에서는 접근이 불가하다.

2. 전역변수(Global variable)

: 함수 외부에서 선언되며 범위(스코프)에 구애받지 않고 프로그램 전체에서 접근할 수 있는 변수

3. 정적변수

4. 외부변수

📌 함수

✔️ 함수 사용 이유 : 기능을 하나의 모듈화 시켜놓고 계속해서 사용할 수 있도록 만들기 위하여

1. 함수 오버로딩

: 함수의 중복 정의 : 함수명이 같고 매개 변수의 타입이나 개수가 다른 함수를 허용하는 것 (즉, 함수명이 같아도 전달받는 인자의 개수나 타입이 다르면 서로 다른 함수로 인식한다.)

❗️ 리턴타입이 다른 것만으로는 허용되지 않는다!

2. 함수 오버라이딩

: 함수의 재정의 (상속에서의 중요한 정의 중 하나) : 함수를 자식 클래스가 재정의할 수 있게 해주는 기능 (override : 무시하다, 거절하다, 무효로 하다, 뒤엎다 등)

3. 재귀 함수

: 최초의 문자열 인코딩 (ASCII, American Standard Code for Information Interchange), 미국 정보 교환 표준 : 7bit로 구성되어 있으며, 영어를 위한 문자, 숫자, 특수문자, 기호 등 128개 문자를 표현할 수 있다. : 모든 문자를 1Byte로 간주 (0-255의 범위 내에 있다.)

1. 장점

• 알파벳(대문자, 소문자)들과 확장 문자를 포함하여 총 256개를 넘지 않는 문자로 이루어져 있다.
• 1Byte(는 256가지의 표현이 가능)를 가지고 충분히 표현할 수 있기에 1Byte의 char형을 사용해서 표현을 할 수 있다.

2. 단점

• 아스키 문자 코드만으로는 한글이나 일어 등의 다른 문자를 표시할 수 없다.
• SBCS로는 프로그램을 국제화(Internationalization(i18n))할 수 없다.

📌 유니 코드 (WBCS, Wide Byte Character Set)

: 전 세계의 모든 문자를 컴퓨터에서 일관되게 표현하고 다룰 수 있도록 설계된 산업 표준 (유니코드 협회 제정) : 모든 문자를 2Byte로 간주 (주의 : 인코딩에 따라 가변적으로 적용됨) : 모든 코드값이 일괄적으로 16비트로 할당 : 대표적인 인코딩 방법 : UTF-

1. 장점

• 유니코드는 지구상에서 통용되는 대부분의 문자들을 담고 있다.
• 2Bytes를 사용하므로 65536개의 표현 범위 덕분에 아스키 코드가 가지는 한계 극복

2. 단점

• 아스키코드의 Char은 1바이트, 유니코드의 Char은 2바이트이기 때문에 printf , scanf 등의 함수는 유니코드와 맞지 않는다. (함수 사용을 위해서는 wprint등 새로 정의된 다른 함수를 사용해야 한다.)

📌 멀티 바이트 코드 (MBCS, Multi Byte Character Set)

: 1Byte만으로는 표현되지 않는 언어들을 표현하기 위해 만들어진 개념 (MicroSoft에서 만든 표준) : 영어 1Byte, 한글 2Byte로 간주 : 유니코드가 생기기 이전 다국어를 표현하기 위해 사용했던 방식 : MBCS는 SBCS와 DBCS를 묶어놓은 Character Set이다.

✔️ DBCS : 하나의 문자세트에 부여된 글자값이 두 바이트 (0-65535의 범위 내에 있다.) : 8비트로 처리할 수 없을 정도로 문자의 종류가 많은 중국, 한국, 일본 그리고 대만 등에서 주로 사용한다.

• ANSI, UTF-8 포함

1. 장점

• 특정 문자 집합마다의 코드페이지가 존재하여 영어 이외의 나라 문자 표현이 가능하다.

✔️ ANSI(American National Standard Institute) : 8bit로 구성되어 있으며 256개의 문자를 표현할 수 있다. : ASCII의 확장판으로 ASCII에서 1bit를 더 사용한다. (앞 7bit는 ASCII와 동일하고, 뒤에 1bit를 이용하여 다른 언어의 문자를 표현한다.) : 새로 추가 된 128개 문자로는 모든 언어의 문자를 표현할 수 없어서 코드페이지가 생겼다. (각 언어별로 Code 값을 주고, Code마다 다른 문자열 표를 의미하도록 약속)

• ANSI = ASCII(7bit) + CodePage(1bit)

✔️ 코드페이지(Code Page) : 마이크로소프트 테크넷에 게재된 각종 컴퓨터용 코드 : 특정 문자 인코딩 테이블을 위해 쓰이는 전통적인 IBM 용어

• 문자 인코딩 테이블 : 0부터 255까지의 정수를 표현하는 단일 옥텟(Octet, 바이트)이라고 불리는 일련의 비트들이 특정한 문자와 결합하여 도표화(Mapping)한 것

2. 단점

• ASCII를 제외하고는 각 DBCS들이 모두 다르다.

📌 T 매크로

❗️ 문자를 처리할 때

• 멀티 바이트 : 기본적으로 Char 사용
• 유니 코드 : wchar_t 사용

참고: 이쿠의 슬기로운 개발생활:티스토리 | https://ikcoo.tistory.com/227

: 기존 컨테이너의 인터페이스를 제한하여 만든 기능이 제한되거나 변형된 컨테이너

✔️ 기존 컨테이너를 감싸는 래퍼를 제공하는 몇 가지 이유

• 코드에 좀 더 의미를 부여하고 싶은 경우
• 의도하지 않는 함수를 실수로 사용하지 못하도록 제한하고 싶은 경우
• 특별한 인터페이스를 새롭게 제공하고 싶은 경우

❓ 스택 (stack)

: 데이터 처리와 보관을 위해 LIFO(Last In Fist Out, 후입선출) 구조를 사용한다.

✔️ 기능적 측면 : 컨테이너의 한쪽 끝에서만 데이터를 삽입하거나 삭제할 수 있으며, 한쪽 끝이 아닌 위치에 있는 데이터는 접근하거나 변경할 수 없다.

• 벡터나 덱은 이러한 기능을 기본적으로 지원하기 때문에 스택을 구현하기 위한 용도로 사용할 수 있다. ❗️ 벡터나 덱을 직접 스택처럼 사용하기에는 약간의 문제가 있다.

std::deque<int> stk1;
stk1.push_back(1);            // 스택에 1 추가: {1}
stk1.push_back(2);            // 스택에 2 추가: {1, 2}
stk1.pop_back();            // 스택에서 맨 위 원소 제거: {1}
stk1.push_front(0);            // 원래 스택에서는 지원하지 않는 동작입니다. : {0, 1}


std::stack<int> stk2;
stk2.push(1);                // 스택에 1 추가: {1}
stk2.push(2);                // 스택에 2 추가: {1, 2}
stk2.pop();                    // 스택에서 맨 위 원소 제거: {1}
stk2.push_front(0);            // 컴파일 에러!

• std::deque을 사용하여 스택 객체 stk1을 만들어 사용

• 이 경우 push_front() 함수처럼 스택에서 사용하면 안 되는 명령 코드를 작성하는 것을 막을 수 없다.

• push_back()_과 _pop_back() 같은 함수 이름은 자료 구조 맨 뒤에 데이터를 추가하거나 삭제한다는 의미인데, 스택으로 사용할 때에는 어느 위치에 데이터가 저장되는지는 알 필요가 없다.

• std::stack을 사용하여 작성된 소스 코드는 어떤 작업을 하고 있는지 좀 더 직관적으로 알 수 있다.

• 의도하지 않은 동작을 지시하거나 실수로 코드를 잘못 작성하는 경우가 발생하지 않게 된다.

1. std::stack

: std::deque으로 만든 간단한 래퍼 (기본 컨테이너 : std::deque) : 스택 자료 구조에서 꼭 필요한 인터페이스만을 제공

✔️ 관련 함수 : empty(), size(), top(), push(), pop(), emplace() -> push() : 기본 컨테이너의 push_back() 함수를 사용하여 구현 -> pop() : pop_back() 함수를 사용하여 구현 -> top() : 기본 컨테이너의 back() 함수 사용 (스택에서 맨 위에 있는 데이터가 덱 구조에서는 맨 끝에 있는 원소이기 때문이다.)

이처럼 기본 컨테이너의 한쪽 끝에서만 원소의 추가 및 삭제를 수행함으로써 LIFO 특징을 제공한다.

✔️ 스택의 모든 연산 시간 복잡도 : O(1)

• 스택에서 기본 컨테이너로 함수 호출을 전달하는 과정은 컴파일러의 최적화에 의해 모두 인라인(inline) 형식으로 호출될 수 있어서 여기서 발생하는 오버헤드는 없다.

2. std::queue

: FIFO(First In First Out, 선입선출) 구조

✔️ 스택과 비슷한 형태의 함수를 지원하며, LIFO 대신 FIFO를 지원하기 위해 그 의미와 동작이 조금 다르게 정의되어 있다. -> push() : std::stack에서의 push_back() -> pop() : pop_front() -> 원소를 제거하는 pop() 함수와 달리, 단순히 양 끝단에 있는 원소에 접근하고 싶을 때에는 front() 또는 back() 함수를 사용한다.

std::queue<int> q;
q.push(1);                    // 맨 뒤에 1을 추가: {1}
q.push(2);                    // 맨 뒤에 2를 추가: {1, 2}
q.push(3);                    // 맨 뒤에 3을 추가: {1, 2, 3}
q.pop();                    // 맨 앞 원소를 제거: {2, 3}
q.push(4);                    // 맨 뒤에 4를 추가: {2, 3, 4}

✔️ 앞서 사용한 모든 함수의 시간 복잡도 : O(1)

3. std::priority_queue

: 우선순위 큐(priority queue)는 힙(heap)이라고 부르는 매우 유용한 구조를 제공

✔️ 힙 : 컨테이너에서 가장 작은(또는 가장 큰) 원소에 빠르게 접근할 수 있는 자료 구조 -> 최소/최대 원소에 접근하는 동작은 O(1)의 시간 복잡도를 가진다. -> 원소 삽입은 O(log n) 시간 복잡도로 동작하며, 원소 제거는 최소/최대 원소에 대해서만 가능하다.

📌 백준 문제 풀이

📌 24-1 게임 개발 프로젝트 기획안 작성

<아이디어 브레인스토밍 및 Backlogs & Sprint 작성>

<게임 기획안 목차>

<회의 진행도>

✔️ 현재 게임 개발 진행중이므로 자세한 게임 기획안은 올리지 않음을 알립니다.

: 양쪽 방향으로 연결된 리스트 : 이중 연결 리스트(double-linked list) 구조

✔️ std::forward_list에 비해 메모리를 조금 더 사용한다!

1. 노드 기본 형태

struct doubly_linked_list_node
{
    int data;
    doubly_linked_list_node* next;
    doubly_linked_list_node* prev;
};

✔️ 이중 연결 리스트 노드는 이전 노드를 가리키는 포인터가 있다. -> 포인터를 이용하여 역방향으로 이동할 수 있으며, 맨 마지막 원소와 리스트 크기를 따로 저장하여 빠른 pushback() 또는 size() 함수를 지원할 수 있다.

✔️ 템플릿 매개변수로 사용자 정의 할당자를 지정할 수 있다.

2. std::list 멤버 함수

✔️ 대부분의 함수가 std::forward_list와 같거나 유사하지만, 약간의 차이가 있다.

1) std::forward_list에서 _after로 끝나는 함수는 std::list에서 _after로 끝나지 않는 형태로 바뀐다. -> insert_after()와 emplace_after() 함수는 insert()_와 _emplace() 함수와 대응된다.

2) std::list에서는 원소 이동을 역방향으로도 할 수 있으므로 원소 삽입을 위해 특정 원소의 이전 원소 반복자를 제공하지 않아도 된다. (대신 정확하게 새로운 원소가 삽입될 위치를 가리키는 반복자를 함수 인자로 전달한다.)

3) std::list는 빠른 push_back(), emplace_back(), pop_back() 함수를 제공한다.

<원소 삽입 및 삭제를 위한 코드 작성 방법>

#include <iostream>
#include <list>

int main()
{
    //리스트 생성 및 새로운 원소 추가
    std::list<int〉 list1 = {1, 2, 3, 4, 5};
    list1.push_back(6);                            // {1, 2, 3, 4, 5, 6}
    list1.insert(next(list1.begin()), 0);        // {1, 0, 2, 3, 4, 5, 6}
    list1.insert(list1.end(), 7);                // {1, 0, 2, 3, 4, 5, 6, 7}

    //리스트 맨 뒤 원소 제거
    list1.pop_back();                            // {1, 0, 2, 3, 4, 5, 6}
    std::cout << "삽입 & 삭제 후 리스트: ";
    for (auto i : list1)
        std::cout << i << " ";
}

✔️ 출력 결과

• 삽입 & 삭제 후 리스트: 1 0 2 3 4 5 6

❗️ 이중 연결 리스트에서 포인터를 관리하기 위해서는 단일 연결 리스트보다 대략 두 배의 연산을 수행해야 한다.

✔️ std::forward_list와 std::list의 push_front(), insert(), pop_front(), erase() 함수 시간 복잡도는 서로 같지만, 실제로는 std::list에서 좀 더 많은 연산이 필요하다. -> 이유 : std::list는 각각의 노드에 두 개의 포인터를 가지고 있고, 삽입 또는 삭제 연산 시 두 개의 포인터를 관리해야 하기 때문이다.

2. 양방향 반복자

• std::list의 반복자는 배열 기반의 임의 접근 반복자와 std::forward_list 기반의 순방향 반복자 중간 정도의 유연성을 가지고 있다.

📌 백준 문제 풀이

2. 데이터(data) 영역

: 전역/정적변수 저장 : 프로그램의 시작과 함께 할당되며, 프로그램이 종료되면 소멸한다.

3. 스택(stack) 영역

: 함수의 호출과 관계되는 지역 변수와 매개변수가 저장되는 영역데이터 구조를 저장하는 데 사용되는 메모리 영역 : 스택 영역은 함수의 호출과 함께 할당되며, 함수의 호출이 완료되면 소멸한다.

✔️ 스택 프레임(stack frame) : 스택 영역에 저장되는 함수의 호출 정보

(1) 동작

: 푸시(push) 동작으로 데이터를 저장하고, 팝(pop) 동작으로 데이터를 인출한다.

• 후입선출(LIFO, Last-In First-Out) 방식 사용

• 가장 늦게 저장된 데이터가 가장 먼저 인출된다.

• 메모리의 높은 주소에서 낮은 주소의 방향으로 할당됩니다.

(2) 장점

• 매우 빠르게 액세스 할 수 있다.
• CPU에 의해 효율적으로 관리되므로 메모리를 수동으로 할당하거나 해제할 필요가 없다.

• 일시적으로 필요한 데이터를 저장하기에 편리하고 안전하다!

(3) 단점

• 사용 가능한 메모리가 제한되어 있다. (컴파일 시간에 결정된다.)

• 스택이 가득차면, 스택 오버플로우가 발생하여 프로그램이 충돌될 수 있다!

• 재귀 함수 호출을 피하는 것이 좋다.

• 변수의 크기 조정이 불가하다.

4. 힙(heap) 영역

: 사용자가 직접 관리해야하는 영역 : 사용자에 의해 메모리 공간이 동적으로 할당되고 해제된다. : 스택에 넣기에는 너무 크거나 여러 함수 또는 코드 블록에서 액세스해야 하는 데이터 구조를 저장하는 데 사용되는 메모리 영역

• 메모리의 낮은 주소에서 높은 주소의 방향으로 할당된다.

(2) 장점

• 변수는 전역적으로 액세스 할 수 있다.
• 메모리 크기 제한이 없다.

(3) 단점

• 엑세스가 느리다.
• 프로그래머가 메모리를 명시적으로 할당하고 해제해야 한다.

• 메모리 할당 : 지정된 크기의 메모리 블록을 예약하는 malloc() 또는 new 함수 호출

• 메모리 해제 : free() 또는 delete 함수 호출

• 효율적으로 공간을 사용하지 않으면 메모리 문제가 일어날 수 있다.

• 메모리 누수 : 메모리가 할당되었지만 해제되지 않음

• 메모리 손상 : 실수로 데이터를 덮어쓰거나 삭제

#include <iostream>
using namespace std;    //std::cout 하지 않고 편하기 쓰기 위해 설정

📌 입력

cin >> a;

📌 출력

cout << a << endl;      //endl은 띄어쓰기! 
                        //문자를 출력하고 싶을 시 "" 붙이기

✔️ 활용

(1) precision()

: 원하는 n자리까지의 출력

cout.precision(n);

✔️ 소수점 이하의 자릿수 다루기

cout << fixed;          //소수점 이하의 n개의 수를 나타낼 것이라는 뜻
cout << precision(n);

(2) EOF 출력

cin.eof()

(3) 특수문자 출력

' 출력 : \'
" 출력 : \"
\ 출력 : \\

: 여러 반복문, 조건문을 종료시키는 역할을 한다.

✔️ return과의 차이점 -> break : 해당하는 반복문, 조건문에서만 종료한다. -> return : 해당하는 문의 전체 함수를 종료하고, 함수가 호출된 지점에서 실행을 계속한다.

#include <iostream>

int breakOrReturn()
{
    while (true) // 무한 루프
    {
        std::cout << "Enter 'b' to break or 'r' to return: ";
        char ch;
        std::cin >> ch;

        if (ch == 'b')
            break; // 루프 밖의 첫 번째 명령문에서 실행이 계속된다.

        if (ch == 'r')
            return 1; // return을 호출하면 함수가 호출자에게 즉시 반환된다 (이 경우 main()).
    }

    // break를 실행하면 여기서부터 실행된다. (루프 밖의 첫 번째 명령문)
    std::cout << "We broke out of the loop\n";

    return 0;
}

int main()
{
    int returnValue = breakOrReturn();
    std::cout << "Function breakOrContinue returned " << returnValue << '\n';

    return 0;
}

📌 continue

: 현재 루프 몸체의 끝으로 이동한다. : 현재 반복을 일찍 종료하고 싶을 때 유용하게 쓰인다. -> coninute 문을 사용하여 일부 코드를 실행하지 않고 점프할 수 있다.

for (int count=0; count  < 20; ++count)
{
    // 숫자가 4로 나눌 수 있는 경우 이 반복을 건너뛴다.
    if ((count % 4) == 0)
        continue; // 루프 몸체 끝으로 점프한다.

    // 숫자가 4로 나눌 수 없는 경우 계속된다.
    std::cout << count << std::endl;

    // continue 문은 여기로 이동시킨다.
}

📌 참고 : 소년코딩 블로그 | https://boycoding.tistory.com/191

1. for 문

: C++에서 가장 많이 사용하는 반복문 : 반복해야 하는 횟수를 정확히 알고 있을 때 사용하기 좋다.

for (초기식; 조건식; 변화식)
   statement // 반복할 명령문

(1) 초기식

: 변수 정의와 초기화로 구성된다. : 루프가 처음 실행될 때 한 번만 평가된다.

(2) 조건식

: 값이 거짓(False)로 평가되면 루프가 즉시 종료된다. : 값이 참(True)로 평가되면 명령문이 실행된다.

(3) 변화식

: 명령문이 실행된 후, 평가된다. : 초기식에서 선언한 변수를 증가 또는 감소시키는데 사용된다.

2. while 문

: 표현식이 참(True)으로 평가되면 명령문이 실행된다.

while (expression)
    statement;

(1) 루프 변수

: 루프가 실행된 횟수를 세는 목적으로 정의된 정수 변수 (카운터(counter)라고도 부름)

• count와 같이 의미 있는 고유한 이름을 사용하는 게 좋다.

#include <iostream>

int main()
{
    int count = 10;

    // count from 10 down to 0
    while (count >= 0)
    {
        if (count == 0)
            std::cout << "blastoff!";
        else
            std::cout << count << " ";
        --count;
    }

    return 0;
}

(2) 무한 루프

: 표현식이 항상 true로 평가되는 while 루프는 영원히 실행한다.

• 종료 방법

• return 문, break 문, exit 문, goto 문 사용

• 예외가 발생하거나 프로그램을 종료

while (1) // or while (true)
{
  // this loop will execute forever
}

3. do-while 문

: 항상 적어도 한번 실행된다. : 주로 루프가 적어도 한번 실행되기를 원하는 경우(ex_ 메뉴를 표시할 때)에 사용한다.

• 사용자에게 메뉴를 표시하고 사용자가 올바른 선택을 할 때까지 기다리는 예제

  #include <iostream>
  

int main() { // selection must be declared outside do/while loop int selection;

do
{
    std::cout << "Please make a selection: \n";
    std::cout << "1) Addition\n";
    std::cout << "2) Subtraction\n";
    std::cout << "3) Multiplication\n";
    std::cout << "4) Division\n";
    std::cin >> selection;
}
while (selection != 1 && selection != 2 &&
    selection != 3 && selection != 4);

// do something with selection here
// such as a switch statement

std::cout << "You selected option #" << selection << "\n";

return 0;

} ```

: 특정 조건에 따라 C++ 프로그램의 흐름을 제어할 수 있도록 해주는 프로그래밍의 기본적인 문법

• 특정 조건이 참(True), 거짓(False)인지 여부에 따라 특정 코드 블록을 실행하고 결정할 수 있다.

1. if 조건문

: 가장 기본적인 조건문

if (expression)  // conditional expression
    statement

or

if (expression)  // conditional expression
    statement
else
    statement2

• expression : 조건식(conditional expression)
• 조건식이 true로 평가되면 if 문이 실행되며, false로 평가되면 else 문이 실행된다.

2. switch 조건문

: switch 표현식이 값을 평가하고, 각 case 레이블의 값과 '같은' 지 테스트한다. : 레이블의 값과 같으면 레이블 뒤의 명령문을 실행한다. : 일치하는 레이블이 없으면 default 뒤의 명령문을 실행한다.

void printColor(Colors color)
{
    switch (color)
    {
        case COLOR_BLACK:
            std::cout << "Black";
            break;
        case COLOR_WHITE:
            std::cout << "White";
            break;
        case COLOR_RED:
            std::cout << "Red";
            break;
        case COLOR_GREEN:
            std::cout << "Green";
            break;
        case COLOR_BLUE:
            std::cout << "Blue";
            break;
        default:
            std::cout << "Unknown";
            break;
    }
}

: 연산 명령을 수행시킬 수 있는 것

** ✔️ 연산자 우선순위(Operator Priority)**

1. 대입 연산자

• =

2. 산술 연산자

(1) 단항 산술 연산자

: 숫자 표현식의 음수 또는 양수 값을 반환한다. 피연산자를 하나만 취한다.

(2) 이항 산술 연산자

: 연산자 왼쪽과 오른쪽에 피연산자를 취한다.

✔️ 정수와 부동 소수점 숫자 나눗셈 -> 두 피연산자 중 하나 이상이 부동 소수점 숫자면 / 연산자는 부동 소수점 나누기를 수행한다. (Ex. 7.0/3=2.333, 7/3.0=2.333, 7.0/3.0=2.333)

(3) 모듈러 연산자(나머지 연산자)

: 나눗셈의 나머지를 구하는 연산 (Ex) %) : 정수 피연산자에서만 작동하며 정수 나눗셈을 수행 후 나머지를 반환한다.

(4) 산술 할당 연산자

: 산술을 간결하게 하도록 도와준다.

3. 증감 연산자

: C++에서는 전위(prefix), 후위(postfix)버전의 두 가지 연산이 있다.

(1) 전위 증감 연산자

: 증가 또는 감소한 다음 값 평가

int x = 5;
int y = ++x; //x=6 / y=6

(2) 후위 증감 연산자

: 컴파일러는 x의 임시 복사본을 만든후, 원본 x를 증가 또는 감소시킨 다음 x의 임시 복사본을 평가한다. 이후 x의 임시 복사본이 삭제 된다.

int x = 5;
int y = x++; //x=5 / y=6

-> 컴파일러는 x와 같은 값을 가진 임시 복사본 x(5) 를 만든다. -> 원본 x를 5에서 6으로 증가시킨다. -> 컴파일러가 5로 평가되는 임시 복사본 x값을 y에 할당한다. -> 임시 복사본이 삭제된다.

✔️ 전위 증감 연산자를 사용하는 것이 후위 증감 연산자를 사용하는 것보다 성능이 더 좋다! -> 후위 증감 연산자로 사용하는 경우, 연산자 우선순위가 가장 나중으로 밀린다.

4. 논리 연산자

: 여러 조건을 테스트할 수 있는 기능을 제공한다.

(1) 논리 부정(Logical NOT)

: 논리 부정 연산자(!)는 부울(bool) 값을 반전시킨다. -> 피연산자 true를 평가하면 false / false를 평가하면 true

✔️ 우선순위가 매우 높으므로 주의해서 사용해야 한다!

//x==y가 아니라면 "x does not equal y"값이 출력되어야 함
//옳지 못한 방법 -> 출력 값 : x equals y
int x = 5;
int y = 7;
if (! x == y)
    cout << "x does not equal y";
else
    cout << "x equals y";
/
/
//올바른 방법 -> 출력 값 : x does not equal y
int x = 5;
int y = 7;
if (!(x == y))
    cout << "x does not equal y";
else
    cout << "x equals y";

(2) 논리 OR(Logical OR) - 논리합

: 두 조건 중 하나가 참(true)인지 테스트하는 데 사용한다.

(3) 논리 AND(Logical AND) - 논리곱

: 두 조건이 모두 참(true)인지 테스트하는 데 사용한다.

5. sizeof 연산자

: 해당 변수의 크기를 반환한다.

6. 조건부 연산자

: C++의 유일한 삼항 연산자(피연산자가 3개)이므로 삼항 연산자라고도 부른다.

• ?: 연산자 : if-else 문을 더 간결하게 사용하는 방법 제공 / 우선순위가 매우 낮다.

✔️ 사용 방법

//일반적인 if-else
if (condition)
    expression;
else
    other_expression;

//?: 연산자 사용
(condition) ? expression : other_expression;

✔️ 활용 예시

//if-else
if (x > y)
    larger = x;
else
    larger = y;

//?:
larger = (x > y) ? x : y;

✔️ 출력하는 코드를 짜고 싶다면 <<연산자가 ?:연산자보다 우선순위가 높으므로 ()를 써야한다!

//if-else
f (x > y)
    std::cout << x;
else
    std::cout << y;
//?:
std::cout << ((x > y) ? x : y);

7. 관계 연산자(비교)

: 각 연산자는 부울 값(bool value) true(1) 또는 false(0)를 반환한다.

✔️ 부동 소수점 숫자 비교 -> 부동 소수점 숫자의 반올림 오류 때문에 관계 연산자를 사용해서 비교하는 것은 위험하다. -> == 또는 !=를 사용하는 것은 권장하지 않는다.

8. 비트 연산자

: 변수 내의 비트(bit)를 조작한다.

• 최적화가 필요한 특정 상황을 제외하고는 잘 쓰지 않는다.
• C++에서는 기호가 있는(signed)정수에서 적용 방식을 보장하지 않으므로 부호 없는(unsigned)정수 자료형을 사용해야 한다.

(1) Bitwise left shift / Bitwise right shift

✔️ 왼쪽 시프트 연산자(<<): 각 비트를 왼쪽으로 이동시킨다.

3 = 0011
3 << 1 = 0110 = 6
3 << 2 = 1100 = 12
3 << 3 = 1000 = 8

• 왼쪽 피연산자 : 이동할 수식
• 오른쪽 피연사자 : 이동할 비트 정수 수
• 3 << 1은 리터럴 3의 비트를 왼쪽으로 1자리 이동시킨다.
• 3 << 3 경우에, 이동한 비트가 왼쪽 끝 범위를 넘어간다. (이진수의 끝에서 벗어난 비트는 손실된다.)

✔️ 오른쪽 시프트 연산자(>>): 각 비트를 오른쪽으로 이동시킨다.

12 = 1100
12 >> 1 = 0110 = 6
12 >> 2 = 0011 = 3
12 >> 3 = 0001 = 1

• 12 << 3 경우에, 이동한 비트가 오른쪽 끝 범위를 넘어간다. (이진수의 끝에서 벗어난 비트는 손실된다.)

✔️ 변수도 시프트할 수 있다!

unsigned int x = 4;
x = x << 1; // x will be 8

(2) Bitwise NOT

• 비트 NOT 연산자(~) : 비트 단위 연산자 중 가장 이해하기 쉽다.

• 각 비트에서 0과 1을 서로 바꾼다.

• 결과값은 자료형의 크기에 따라 다르다.

//4bits
4 = 0100
~4 = 1011 = 11 (decimal)

//8bits
4 = 0000 0100
~4 = 1111 1011 = 251 (decimal)

(3) Bitwise AND, OR, XOR

• 비트 AND 연산자(&), 비트 OR 연산자(|) : 논리 AND 연산자(&&) 및 논리 OR 연산자(||)와 비슷하게 동작한다.

• But, bool 값을 평가하는 대신 각 비트에 적용된다. (비트의 각 열에 연산이 적용된다.)

• 비트 OR 연산자(|) : 비트 두개 중 하나 이상이 1이면 1로 평가된다.

  //5 | 6: 0111(7)
  0 1 0 1 // 5
  0 1 1 0 // 6

0 1 1 1 // 7

- **비트 AND 연산자**(`&`) : 두 비트 모두 1인 경우에만 1로 평가된다. 
```cpp
//5 & 6: 0100(4)
0 1 0 1 // 5
0 1 1 0 // 6
--------
0 1 0 0 // 4

• 비트 XOR 연산자(^) : 두 연산자를 평가할 때, 한 개의 피연산자만 1인 경우에만 1로 평가된다. (같으면 0, 다르면 1)

  //5 ^ 6: 0101(5)
  0 1 1 0 // 6
  0 0 1 1 // 3

0 1 0 1 // 5

</br>

- **활용 코드** (게임 캐릭터의 상태값을 조절할 때 많이 사용함)
```cpp
#define HUNGRY 1(0x1)
#define THIRSTY 2(0x2)
#define TIRED 4(0x4)
#define FIRE 8(0x8)
#define COLD 16(0x10)
#define POISON 32(0x20)
//이후부터는 (0x40,0x80,0x100,0x200...등)

unsigned int iStatus = 0;

//상태 추가
iStatus |= HUNGRY;
iStatus |= THIRSTY;

//상태 확인
if (iStatus & THIRSTY)
{
}

//특정 자리 비트 제거
iStatus &= ~THIRSTY;

9. 비트 할당 연산자

📌 참고 : 소년코딩 블로그 | https://boycoding.tistory.com/158

✔️ 1바이트 = 8비트 = 2^8 : 256가지의 표현 가능(0~255)

📌 자료형(Data Type)

: 변수가 어떠한 자료의 형태를 나타내는지 알려준다.

정수와 실수는 표현하는 방식이 다르다.

1. 정수형

• char, short, int, long
• long long : int형 연산에서 초과되는 범위를 다룰 때 사용

✔️ 양수만 취급하고 싶을 경우 unsigned를 앞에 붙여야 함!

(1) 자료형에 따라 달라지는 양수, 음수

✔️ 맨 앞자리 비트(MSB: Most Significant Bit)가 0일 경우 : 양수 -> 128개 ✔️ 맨 앞자리 비트(MSB: Most Significant Bit)가 1일 경우 : 음수 -> 128개

하지만 무조건 MSB가 0,1이라고 양수,음수가 아니다!!!!!!! 즉, 양수로 사용할 때는 굳이 비트를 안 봐도 되지만 양수,음수 둘 다 표현할 때는 MSB 확인!

//0~255 표현
unsigned char c = 0;
c = 255; //255로 들어감 (비트 상태 : 1111 1111) -> 양수
c = -1; //255로 들어감

//-128~127 표현
char c1 = 0;
c1 = 255; //-1로 들어감 (비트 상태 : 1111 1111) -> 음수

❗️ 동일한 메모리 공간에 같은 값으로 채워지더라도 어떻게 해석하느냐에 따라 달라진다!

(2) 2의 보수법

: 주로 음의 정수를 찾을 때 사용한다.

✔️ 사용법 : 대응되는 양수의 부호를 반전 후, 1을 더한다.

2. 실수형

: 정밀도에 의존 : 부동 소수점 표현 방식 사용 -> 가장 근사한 값으로 비트 표현

• float
• double : 더 정밀한 표현이 가능 (float보다 더 아래의 소수점까지 정확하게 표현이 가능)

✔️ 실수를 상수로 적을 경우, 소수점 뒤에 f를 붙이면 float, 안 붙이면 double으로 간주한다.

✔️ 정수는 정수끼리, 실수는 실수끼리 연산하되, 두 표현방식의 피 연산자가 연산될 경우 명시적으로 변환! Ex) float f = 10.2415f + (float)20;

: 연결 리스트와 같은 형태의 자료 구조 : 기본적인 연결 리스트에 대한 래퍼 클래스 (C++이 제공) : C++에서 제공하는 연결 리스트 관련 컨테이너

✔️ 기본적인 연결 리스트를 구성하려면 포인터를 하나 가지고 있어야 하고, new와 delete 연산자를 이용하여 메모리를 할당하고 해제할 수 있어야 한다. -> 이러한 기능을 구현하는 것이 그리 어렵지는 않지만 자칫 잘못하면 찾기 어려운 버그를 양산할 수 있다.

✔️ 많은 응용 프로그램에서는 자료 구조 중간에 삽입 또는 삭제 작업을 필요로 한다. Ex) 탭을 지원하는 브라우저 : 언제든 새로운 탭을 임의의 위치에 옮길 수 있어야 한다. 음악 플레이어 : 재생 목록 중간에 새로운 노래를 추가할 수 있어야 한다.

-> 빠른 동작을 위해 연결 리스트를 사용할 수 있다. (음악 플레이어를 만드는 '실습 문제 1: 음악 재생 목록 구현하기'에서 연결 리스트의 사용 예를 확인할 수 있다.)

1. 추가적인 기능 제공

• 기본적인 연결 리스트의 성능을 유지하면서 추가적인 기능을 제공한다.

• 성능 유지를 위해 std::forward_list는 전체 리스트의 크기를 반환하거나 첫 번째 원소를 제외한 나머지 원소에 직접 접근하는 기능을 제공하지 않는다.

• 맨 처음 원소에 접근하는 front() 함수 제공

• 반대 방향의 원소로 이동하는 back() 같은 함수 제공 X

• 원소의 삽입, 삭제, 순서 뒤집기, 분할을 위한 기능을 제공한다.

• 기본적인 연결 리스트의 메모리 사용량이나 성능에 영향을 주지 않는다.

• std::vector와 마찬가지로 두 번째 템플릿 매개변수에 사용자 지정 할당자를 지정할 수 있다.

• 맞춤형 메모리 관리가 필요한 고급 응용 프로그램에서도 std::forward_list를 사용할 수 있다.

2. 원소 삽입/ 삭제

1. 원소 삽입

• push_front() 함수

• 연결 리스트 맨 앞에 새로운 원소를 삽입

• std::forward_list는 마지막 원소에 직접 접근할 수 없으므로 push_back() 함수 제공 X

• insert_after() 함수

• 특정 위치에 원소를 삽입시 사용

• 연결 리스트에서 새로운 원소를 삽입한 후, 해당 위치 앞에 있는 원소의 next 포인터를 수정해야 하기 때문에 insert() 사용 X

📌 백준 문제 풀이