#include <stdio.h> //์ ์ฒ๋ฆฌ๊ธฐ
๋ฉ์ธํจ์์ ๋ฐํํ์
void๋ก ํด๋ ์๊ด ์์ผ๋, int๋ก ํด์ ๋ฐํ๊ฐ์ 0์ผ๋ก ์ฃผ๋ ๊ฒ์ด ํจ์ ์์ ์ ์ด๋ค.
void๋ ๋ฐํ๊ฐ์ด ์๊ธฐ๋๋ฌธ์ main ํจ์ ์ข
๋ฃ ํ ๋ฐํ๊ฐ์ด ์๋ ๊ฒ์ด ์ข๋ค.
VS์์ ํ๋จ ์ถ๋ ฅ๋ณด๊ธฐ๋ฅผ ๋น๋๋ก ์ค์ ํด์ ํ์ธํ๋ฉด, warning์ด๋ ์ค๋ฅ์ ์์ธ์ด ๋์ค๋๋ฐ ์ต๋ํ ์๊ฒ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ์ข๋ค.
์์จ๋ ์ ์์ ์ผ๋ก ์คํ๋์ง๋ง ๋ฉ์ธ์์๋ง ๊ฐ๋ฅํ๋ฉฐ, ๋ฐํ์ ํด์ฃผ๋ ๊ฒ์ด ์ข๋ค.
1byte == 8bit
์ด์์ฒด์ ์ 64bit, 32bit๋ cpu๊ฐ ์์
ํ๋ ์ต์๋จ์๋ผ๊ณ ๋ณด๋ฉด๋๋ค.
ใด intํ์ ํ๋ก๊ทธ๋๋ฐ์ ์ต์ ์ ๋จ์๋ผ๊ณ ๋ณด๋ฉด๋๋ฉฐ, ์์
์๋๊ฐ ๊ฐ์ฅ ๋น ๋ฅด๋ค
[์๋ฃํ(Variable)]
์ ์ํ
ใด char: 1byte / ํํ๋ฒ์ -128~127
ใด short: 2byte
ใด int: 4byte
ใด long: 4byte
ใด ์ด์์ฒด์ ๋ ๋๋ฒ๊น
ํ๊ฒฝ์ด ์์ดํด์ง ๊ฒฝ์ฐ ๋ฌ๋ผ์ง ์๋ ์๊ธดํจ (long์ ์ฝํ
์์ 8byte์ผ ํ๋ฅ ์ด ๋์)
ใด long long ์ด๋ฐ์์ผ๋ก 8byte์ง๋ฆฌ ์ ์ํ์ผ๋ก ์ด๋ค (์๋ฃํ ์์ ๋ถ์ฌ์ ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์)
ใด long long ํ์ ์ฃผ๋ก ์๊ฐ์ ๊ด๋ฆฌํ ๋, ์๋ฒ ํต์ ํ ๋ ์ฌ์ฉํ๋ค.
ใด long int๋ 4byte
์ค์ํ
ใด float: 4byte
ใด double: 8byte
์ด์ง๋ฒ์ ์์๋ฅผ ํํํ ์ ์์ / ๋ถ๋์์์ ์ ์ฌ์ฉํ๋ค.
0.123 -> 123 * 10 -3์น ์ด๋ ๊ฒ ์ธ์ํจ
๋ณ์: ๋ณํ๋ ์
[์ฐ์ฐ์(Operator)]
๊ธฐ๋ณธ์ฐ์ฐ์
ใด + ๋ง์
ใด - ๋บ์
ใด * ๊ณฑ์
ใด / ๋๋์
ใด % ๋๋จธ์ง
๋์
์ฐ์ฐ์
ใด = : ๊ฐ์ ๋์
ใด += :
ใด -= : ๋ณธ์ธ ์ค์ค๋ก์ ๋นผ์ ๋์
ใด *= : ๋ณธ์ธ ์ค์ค๋ก์ ๊ณฑํด์ ๋์
ใด /= : ๋ณธ์ธ ์ค์ค๋ก์ ๋๋ ์ ๋์
ใด %= : ๋ณธ์ธ ์ค์ค๋ก์ ๋๋จธ์ง๋ฅผ ๋์
x = x + y๋ฅผ x += y; ๋ก ์ค์ฌ์ธ ์ ์๋ค. (๋ค๋ฅธ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง)
๋น๊ต์ฐ์ฐ์ (๊ฐ์ 1 or 0 ์ ๋ฐํํ๋ค)
ใด == : ๊ฐ๋ค
ใด <, <= : ์๋ค, ์๊ฑฐ๋ ๊ฐ๋ค
ใด >, >= : ํฌ๋ค, ํฌ๊ฑฐ๋ ๊ฐ๋ค
ใด != : ๊ฐ์ง์๋ค
๋
ผ๋ฆฌ์ฐ์ฐ์(bool ๊ฐ์ ๋ฐํํ๋ค)
ใด && : (๊ทธ๋ฆฌ๊ณ ) ๋ ๋ค ์ฐธ์ผ ๊ฒฝ์ฐ๋ง ์ฐธ์ ๋ฐํ
ใด || : (๋๋) ๋์ค ํ๋๋ง ์ฐธ์ผ ๊ฒฝ์ฐ๋ง ์ฐธ์ ๋ฐํ
๋นํธ์ฐ์ฐ์
ใด << : ์ํํธ์ฐ์ฐ์๋ 2์ n์น์ ํ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
ใด >> : ๋ฐ์ผ๋ก ๋๋๋ ํจ๊ณผ๋ฅผ ์ค๋ค.
ํ๋ก๊ทธ๋๋ฐ์์๋ ๊ณฑ์
์ฐ์ฐ์๊ฐ ๋น ๋ฅด๊ณ ๋๋์
์ฐ์ฐ์๋ ์ฒ๋ฆฌ์๋๊ฐ ๋๋ฆฐํธ์ด๋ค.
ใด ๋๋ ์ผ์ด ์์ ๊ฒฝ์ฐ *0.5f ํ๋ ์์ผ๋ก ๊ณฑํ๋ ๊ฒ์ด ์ข๋ค.
ใด ์ํํธ์ฐ์ฐ์๋ ๊ณฑ์
์ฐ์ฐ์๋ณด๋ค ๋น ๋ฅธ ํธ์ด๊ธฐ ๋๋ฌธ์ ๋จ์ํ 2๋ฐฐ๊ฐ ํ์ํ ๊ฒฝ์ฐ ์ฌ์ฉํ๊ธฐ ์ข๋ค. (ํน๋ณํ ๋ง์ด ์ฐ์ด์ง ์์ผ๋ ์ด๋ ๊ฒ ์ธ ์ ์๋ ์ ๋๋ง ์์๋๋ฉด ์ข๋ค)
================
CPU ๋ฉ๋ชจ๋ฆฌ RAM
GPU ๋ฉ๋ชจ๋ฆฌ VRAM
ใด ํ๋ก๊ทธ๋จ ์คํ ์ ๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ์ฌ ์ฐ์ฐ์์
์ ํ๋ค
==========
ํจ์ ๋ด์์ ์ฐ๋ ๋ณ์: ์ง์ญ๋ณ์ (์ค์ฝํ ๋ด์์)
ใด ์ง์ญ๋ณ์๋ ์ด๊ธฐํํด์ค์ผํจ
int x, y;
x = y = 0;
int x = 0, y = 0;
์ด๋ ๊ฒ ์ด๊ธฐํ ํ ์๋ ์๋น.
1๋ก ์ด๊ธฐํํ๊ณ ์๋ฃํ์ float์ผ๋ก ํ ๊ฒฝ์ฐ 0์ด ์ถ๋ ฅ๋๋๋ฐ, ๋ถ๋์์์ ๊ณ์ฐ๋๋ก ๊ณ์ฐํ๋ฉด ์ ๋๋ก ์ถ๋ ฅ๋์ง ์์ ์ ์์ผ๋
๋ง๋ ์๋ฃํ์ ์ฌ์ฉํ ์ ์๊ฒ ์ฃผ์๊ฐ ํ์ํ๋ค.
================
[์กฐ๊ฑด๋ฌธ(Conditional)]
if๋ฌธ
if(์กฐ๊ฑด)
{
์คํ๋ฌธ....
}
ใด ์กฐ๊ฑด์ด ์ฐธ์ด๋ฉด ์คํํ๊ณ ์๋๋ฉด ์ํจ
else if(์กฐ๊ฑด)
{
}
ใด if์กฐ๊ฑด์ด ์๋๋ else if ์กฐ๊ฑด์ด ๋ง๋ค๋ฉด ์คํ๋ฌธ ์คํ
else
{
}
ใด ์์ ํด๋นํ์ง ์๋ ๊ฒฝ์ฐ else ์คํ๋ฌธ ์คํ
ใด ์ค๋จ์ ์ ์ฐ์ด์ ํ์ธํด๋ณผ ๊ฒฝ์ฐ ๊ฐ ์กฐ๊ฑด๋ง๋ค ํด๋นํ๋์ง๋ฅผ ํ์ธํ๋ค
switch๋ฌธ
switch(๋ณ์)
case 1 :
break;
case 2:
break;
default:
break;
ใด ์ค๋จ์ ์ ์ฐ์ด์ ํ์ธํด๋ณผ ๊ฒฝ์ฐ if๋ฌธ๊ณผ ๋ค๋ฅธ ์ ์ ๊ฐ ์กฐ๊ฑด์ ์ ๋ถ ์ดํด๋ณด์ง์๊ณ ํด๋นํ๋ ์ผ์ด์ค๋ก ๋ฐ๋ก ๋์ด๊ฐ๋ค.
switch๋ฌธ์ ์ธ ์ ์๋ ์ํฉ์๋ switch๋ฌธ์ ์ฐ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ด๋ค
===========
๊ฐ ์ธ์ด๋ง๋ค ๋ณ์๋ช
์ ์ง๋ ๋ค์ด๋ฐ๋ฐฉ๋ฒ์ด ์์ดํ๋ค.
ใด C++์ ํ๊ฐ๋ฆฌํ๊ธฐ๋ฒ์ ์์ฆ์๋ ๋ง์ด ์ฐ์ด๊ธดํ๋ ์ค์ด๋ ์ถ์ธ
์๋ฌธ์์์, ๋ค์ ๋จ์ด์ ๋๋ฌธ์ ์ฐ๋ ๊ฒ์ ์นด๋ฉ ํ๊ธฐ๋ฒ
rand() ํจ์๋ ์๋๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ ๋งค๋ฒ ๊ฐ์ ๊ฐ์ด ๋์จ๋ค.
ใด srand()๋ ์๋๊ฐ์ ๋ฃ์ด์ค. ์๋๊ฐ์ ์๊ฐ์ ๋ฃ์ด์ฃผ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ๋งค๊ฐ๋ณ์๋ unsigned int
ใด time(0) // 0์ด nullptr์ ์์คํค๊ฐ์ด๋ผ๊ณ ํ๋ค
๋๋ค๊ฐ์ ๋ฒ์๋ฅผ ์ง์ ํ๊ณ ์ถ๋ค๋ฉด ๋๋จธ์ง์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ค.
rand() % 100 ์ด๋ฐ์์ผ๋ก!
50~100๊น์ง ํ๋ ค๋ฉด rand() % 100 + 50
============
๋๋ฒ๊น
ํ๋ ๋ฐฉ๋ฒ
ใด ํด๋นํ๋ ์ค์์ F9๋๋ฅด๋ฉด ์ค๋จ์ (๋ธ๋ ์ดํฌํฌ์ธํธ)๊ฐ ์์ฑ๋๋ค.
ใด ์ด์ํ๋ก ์คํ์ํค๋ฉด ํด๋น ์ค๋จ์ ์ด ์คํ๋ ๋ ๋ฉ์ถ๊ณ ๋ณด์ฌ์ค
๋ค์์ค ์คํ์ F10
๋๊ธ