๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“ Development Study/๐Ÿ’ป Win32API

๋ณ€์ˆ˜ ๋ฐ ์œ ํ˜•

by eazuooz 2022. 8. 17.

์ด์ „ ์žฅ์—์„œ ๋ณด์—ฌ์ค€ "Hello World" ํ”„๋กœ๊ทธ๋žจ์˜ ์œ ์šฉ์„ฑ์€ ๋‹ค์†Œ ์˜์‹ฌ์Šค๋Ÿฝ์Šต๋‹ˆ๋‹ค. ๋ช‡ ์ค„์˜ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ณ  ์ปดํŒŒ์ผํ•œ ๋‹ค์Œ ๊ฒฐ๊ณผ ํ”„๋กœ๊ทธ๋žจ์„ ์‹คํ–‰ํ•ด์•ผ ํ™”๋ฉด์— ์ž‘์„ฑ๋œ ๊ฐ„๋‹จํ•œ ๋ฌธ์žฅ์˜ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ์ถœ๋ ฅ ๋ฌธ์žฅ์„ ์ง์ ‘ ์ž…๋ ฅํ•˜๋Š” ๊ฒƒ์ด ํ›จ์”ฌ ๋” ๋นจ๋ž์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ํ™”๋ฉด์— ๊ฐ„๋‹จํ•œ ํ…์ŠคํŠธ๋ฅผ ์ธ์‡„ํ•˜๋Š” ๋ฐ๋งŒ ๊ตญํ•œ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์กฐ๊ธˆ ๋” ๋‚˜์•„๊ฐ€์„œ ์‹ค์ œ๋กœ ์ž‘์—…์„ ์ ˆ์•ฝํ•˜๋Š” ์œ ์šฉํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•˜๋ ค๋ฉด ๋ณ€์ˆ˜ ๊ฐœ๋…์„ ๋„์ž…ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค .

์ˆซ์ž 5๋ฅผ ๊ธฐ์–ตํ•˜๋ผ๊ณ  ํ•œ ๋‹ค์Œ ์ˆซ์ž 2๋„ ๋™์‹œ์— ์™ธ์šฐ๋ผ๊ณ  ํ•œ๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋ฉ”๋ชจ๋ฆฌ์— ๋‘ ๊ฐœ์˜ ๋‹ค๋ฅธ ๊ฐ’(5 ๋ฐ 2)์„ ์ €์žฅํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด์ œ ๋‚ด๊ฐ€ ๋งํ•œ ์ฒซ ๋ฒˆ์งธ ์ˆซ์ž์— 1์„ ๋”ํ•˜๋ผ๊ณ  ์š”์ฒญํ•˜๋ฉด ์ˆซ์ž 6(์ฆ‰, 5+1)๊ณผ 2๋ฅผ ๊ธฐ์–ตํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ์˜ˆ๋ฅผ ๋“ค์–ด ์ด๋Ÿฌํ•œ ๊ฐ’์„ ๋นผ์„œ ๊ฒฐ๊ณผ๋กœ 4๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์œ„์—์„œ ์„ค๋ช…ํ•œ ์ „์ฒด ํ”„๋กœ์„ธ์Šค๋Š” ์ปดํ“จํ„ฐ๊ฐ€ ๋‘ ๊ฐœ์˜ ๋ณ€์ˆ˜๋กœ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ๊ณผ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค. ๋™์ผํ•œ ํ”„๋กœ์„ธ์Šค๋ฅผ ๋‹ค์Œ ๋ช…๋ น๋ฌธ ์„ธํŠธ๋กœ C++๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

a = 5;
b = 2;
a = a + 1;
result = a - b;

ํ‚ค์›Œ๋“œ์™€ ์‹๋ณ„์ž

ํ‚ค์›Œ๋“œ๋Š” ์—ฌ๋Ÿฌ๊ฐ€์ง€ ๋ฌธ๋ฒ•๋“ค์„ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด์„œ c++์—์„œ ์ง€์›ํ•˜๋Š” ๋‹จ์–ด๋“ค์ž…๋‹ˆ๋‹ค.

 

์‹๋ณ„์ž๋Š” ๋ณ€์ˆ˜, ํ•จ์ˆ˜, ํด๋ž˜์Šค๋ช…๋“ฑ ์šฐ๋ฆฌ๊ฐ€ ๋ฉ”๋ชจ๋ฆฌ์˜ ์„œ๋กœ๋‹ค๋ฅธ ๊ณต๊ฐ„์„ ๊ตฌ๋ถ„ํ•˜๊ธฐ์œ„ํ•ด ์ง€์–ด์ง„

์ด๋ฆ„์„ ์ด์•ผ๊ธฐํ•ฉ๋‹ˆ๋‹ค. 

 

  • ํ‚ค์›Œ๋“œ๋Š” ์˜ˆ์•ฝ๋˜์–ด ์žˆ์œผ๋ฏ€๋กœ ํ‚ค์›Œ๋“œ๋Š” ์‹๋ณ„์ž๊ฐ€ ๋ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.
  • ์‹๋ณ„์ž๋Š” ๋Œ€์†Œ๋ฌธ์ž, ์ˆซ์ž ๋ฐ ๋ฌธ์ž๋กœ๋งŒ ๊ตฌ์„ฑ๋ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ์‹๋ณ„์ž๋Š” ๋Œ€์†Œ๋ฌธ์ž ๋˜๋Š” _ ๋ฌธ์ž๋กœ๋งŒ ์‹œ์ž‘๋˜์•ผ ํ•ฉ๋‹ˆ๋‹ค. ( ์ˆซ์ž๋กœ ์‹œ์ž‘๋ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. )
  • C++์€ ๋Œ€๋ฌธ์ž์™€ ์†Œ๋ฌธ์ž๋ฅผ ๊ตฌ๋ถ„ํ•ฉ๋‹ˆ๋‹ค.

    alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq

    ํŠน์ • ์ปดํŒŒ์ผ๋Ÿฌ์—๋Š” ์ถ”๊ฐ€๋กœ ํŠน์ • ์˜ˆ์•ฝ๋œ ํ‚ค์›Œ๋“œ๊ฐ€ ์žˆ์„ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ์œ ํ˜•

๋ณ€์ˆ˜์˜ ๊ฐ’์€ ์ปดํ“จํ„ฐ ๋ฉ”๋ชจ๋ฆฌ์— 0๊ณผ 1๋กœ ์ €์žฅ๋ฉ๋‹ˆ๋‹ค. ์šฐ๋ฆฌ ํ”„๋กœ๊ทธ๋žจ์€ ๋ณ€์ˆ˜๊ฐ€ ์ €์žฅ๋œ ์ •ํ™•ํ•œ ์œ„์น˜๋ฅผ ์•Œ ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. ๋‹จ์ˆœํžˆ ์ด๋ฆ„์œผ๋กœ ๊ฐ€์ ธ๋‹ค๊ฐ€ ์‚ฌ์šฉํ• ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ”„๋กœ๊ทธ๋žจ์ด ์•Œ์•„์•ผ ํ•  ๊ฒƒ์€ ๋ณ€์ˆ˜์— ์ €์žฅ๋œ ๋ฐ์ดํ„ฐ์˜ ์ข…๋ฅ˜์ž…๋‹ˆ๋‹ค. ๋‹จ์ˆœํ•œ ์ •์ˆ˜๋ฅผ ์ €์žฅํ•˜๋Š” ๊ฒƒ์€ ๋ฌธ์ž๋‚˜ ํฐ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž๋ฅผ ์ €์žฅํ•˜๋Š” ๋ฐฉ์‹์ด ๋‹ค๋ฆ…๋‹ˆ๋‹ค. ๋ชจ๋‘ 0๊ณผ 1์„ ์‚ฌ์šฉํ•˜์—ฌ ํ‘œ์‹œ๋˜์ง€๋งŒ ๋™์ผํ•œ ๋ฐฉ์‹์œผ๋กœ ํ•ด์„๋˜์ง€ ์•Š์œผ๋ฉฐ ๋งŽ์€ ๊ฒฝ์šฐ ๋™์ผํ•œ ์–‘์˜ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์ฐจ์ง€ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์€ ๋Œ€๋ถ€๋ถ„์˜ ์‹œ์Šคํ…œ์—์„œ ๊ธฐ๋ณธ์ ์œผ๋กœ ์ง€์›ํ•˜๋Š” ๊ธฐ๋ณธ ์ €์žฅ ๋‹จ์œ„๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์–ธ์–ด๋กœ ์ง์ ‘ ๊ตฌํ˜„๋˜๋Š” ๊ธฐ๋ณธ ์œ ํ˜•์ž…๋‹ˆ๋‹ค. ์ฃผ๋กœ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ถ„๋ฅ˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • ๋ฌธ์ž ์œ ํ˜• : 'A' ๋˜๋Š” ์™€ ๊ฐ™์€ ๋‹จ์ผ ๋ฌธ์ž๋ฅผ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค '$'. ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์œ ํ˜•์€ char1๋ฐ”์ดํŠธ ๋ฌธ์ž์ž…๋‹ˆ๋‹ค. ๋” ๋„“์€ ๋ฌธ์ž๋ฅผ ์œ„ํ•ด ๋‹ค๋ฅธ ์œ ํ˜•๋„ ์ œ๊ณต๋ฉ๋‹ˆ๋‹ค.
  • ์ •์ˆ˜ ์œ ํ˜• : 7 ๋˜๋Š” ์™€ ๊ฐ™์€ ์ •์ˆ˜ ๊ฐ’์„ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค 1024. ๋‹ค์–‘ํ•œ ํฌ๊ธฐ๋กœ ์กด์žฌํ•˜๋ฉฐ ์Œ์ˆ˜ ๊ฐ’์„ ์ง€์›ํ•˜๋Š”์ง€ ์—ฌ๋ถ€์— ๋”ฐ๋ผ ๋ถ€ํ˜ธ ๊ฐ€ ์žˆ๊ฑฐ๋‚˜ ๋ถ€ํ˜ธ ๊ฐ€ ์—†์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋ถ€๋™ ์†Œ์ˆ˜์  ์œ ํ˜• : ์„ธ ๊ฐ€์ง€ ๋ถ€๋™ ์†Œ์ˆ˜์  ์œ ํ˜• ์ค‘ ์‚ฌ์šฉ๋˜๋Š” ์œ ํ˜•์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ์ •๋ฐ€๋„ ์ˆ˜์ค€ ์œผ๋กœ 3.14๋˜๋Š” ์™€ ๊ฐ™์€ ์‹ค์ œ ๊ฐ’์„ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค .0.01
  • BOOL ์œ ํ˜• : C++์—์„œ ๋กœ ์•Œ๋ ค์ง„ ๋ถ€์šธ ์œ ํ˜• bool์€ ๋‘ ๊ฐ€์ง€ ์ƒํƒœ true๋˜๋Š” false.

 

๊ตฌ๋ถ„์ž๋ฃŒํ˜•ํฌ๊ธฐ๋ฒ”์œ„

๊ธฐ๋ณธํ˜• void
๋ฌธ์žํ˜• (signed) char 1 byte -128 ~ 127
unsigned char 1 byte 0 ~ 255
wchar_t 2 byte 0 ~ 65,535
์ •์ˆ˜ํ˜• bool 1 byte 0 ~ 1
(signed) short (int) 2 byte -32,768 ~ 32,767
unsigned short (int) 4 byte 0 ~ 65,535
(signed) int 4 byte -2,147,483,648 ~ 2,147,483,647
unsigned int 4 byte 0 ~ 4,294,967,295
(signed) long (int) 4 byte -2,147,483,648 ~ 2,147,483,647
unsigned long (int) 4 byte 0 ~ 4,294,967,295
__int8 1 byte -128 ~ 127
__int16 2 byte -32,768 ~ 32,767
__int32 4 byte -2,147,483,648 ~ 2,147,483,647
__int64 8 byte -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
์‹ค์ˆ˜ํ˜• float 4 byte 3.4E-38(-3.4*10^38) ~ 3.4E+38(3.4*10^38) (7digits)
(long) double 8 byte 1.79E-308(-1.79*10^308) ~ 1.79E+308(1.79*10^308) (15digits)


signed๋Š” C/C++ ํ”„๋กœ๊ทธ๋žจ ์–ธ์–ด์—์„œ ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜ ์ค‘ ๋ถ€ํ˜ธ๋ฅผ ๊ฐ–๋Š” ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธ ํ•œ๋‹ค. ์ •์ˆ˜ํ˜• ์ค‘ ์Œ์ˆ˜๋Š” 2์˜ ๋ณด์ˆ˜ ์ฒด๊ณ„๋ฅผ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ ์ด ํ‚ค์›Œ๋“œ์— ์˜ํ•ด ๋ถ€ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ๋ณ€์ˆ˜ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ •์ˆ˜ํ˜•์˜ ๋ณ€์ˆ˜์—์„œ unsigned๊ฐ€ ์—†์œผ๋ฉด ์Œ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋ถ€ํ˜ธ๋ฅผ ๊ฐ–๋Š” ์ •์ˆ˜ํ˜•์ด ๋œ๋‹ค. 

 char(์ •ํ™•ํžˆ 1๋ฐ”์ดํŠธ์˜ ํฌ๊ธฐ๋ฅผ ๊ฐ€์ง) ๊ธฐ๋ณธ ์œ ํ˜• ์ค‘ ์–ด๋А ๊ฒƒ๋„ ํ‘œ์ค€ ํฌ๊ธฐ๊ฐ€ ์ง€์ •๋˜์ง€ ์•Š์•˜์Šต๋‹ˆ๋‹ค. ๋ชจ๋“  ์ปดํŒŒ์ผ๋Ÿฌ์™€ ์ปดํ“จํ„ฐ์— ํ‘œ์ค€ ํฌ๊ธฐ๊ฐ€ ์—†๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ๊ฐ ์ปดํŒŒ์ผ๋Ÿฌ ๋งˆ๋‹ค ํ”„๋กœ๊ทธ๋žจ์ด ์‹คํ–‰๋  ๋•Œ ์ ํ•ฉํ•œ ์ด๋Ÿฌํ•œ ์œ ํ˜•์˜ ํฌ๊ธฐ๋ฅผ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.



ํฌ๊ธฐ๊ณ ์œ ํ•œ ํ‘œํ˜„ ๊ฐ€๋Šฅํ•œ ๊ฐ€์น˜๋ฉ”๋ชจ

8๋น„ํŠธ 256 = 2^8
16๋น„ํŠธ 65 536 = 2^16
32๋น„ํŠธ 4 294 967 296 = 2^32 (~40์–ต)
64๋น„ํŠธ 18 446 744 073 709 551 616 = 2^64 (~180์–ต)


์ •์ˆ˜ ์œ ํ˜•์˜ ๊ฒฝ์šฐ ํ‘œํ˜„ ๊ฐ€๋Šฅํ•œ ๊ฐ’์ด ๋” ๋งŽ๋‹ค๋Š” ๊ฒƒ์€ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ๋” ํฌ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, 16๋น„ํŠธ ๋ถ€ํ˜ธ ์—†๋Š” ์ •์ˆ˜๋Š” 0์—์„œ 65535๊นŒ์ง€์˜ ๋ฒ”์œ„์—์„œ 65536๊ฐœ์˜ ๊ณ ์œ ํ•œ ๊ฐ’์„ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ๋Š” ๋ฐ˜๋ฉด ๋ถ€ํ˜ธ ์žˆ๋Š” ์ •์ˆ˜๋Š” ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ -32768์—์„œ 32767 ์‚ฌ์ด์˜ ๊ฐ’์„ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 16๋น„ํŠธ ์ค‘ ํ•˜๋‚˜๊ฐ€ ๋ถ€ํ˜ธ์— ์‚ฌ์šฉ๋œ๋‹ค๋Š” ์‚ฌ์‹ค ๋•Œ๋ฌธ์— ์–‘์ˆ˜ ๊ฐ’์€ ๋ถ€ํ˜ธ ์—†๋Š” ์œ ํ˜•์— ๋น„ํ•ด ๋ถ€ํ˜ธ ์žˆ๋Š” ์œ ํ˜•์—์„œ ๋Œ€๋žต ์ ˆ๋ฐ˜์œผ๋กœ ์ค„์–ด๋“ญ๋‹ˆ๋‹ค. 

๋ถ€๋™ ์†Œ์ˆ˜์  ์œ ํ˜•์˜ ๊ฒฝ์šฐ ํฌ๊ธฐ๋Š” ์œ ํšจ ๋ฐ ์ง€์ˆ˜์— ๋Œ€ํ•ด ๋” ๋งŽ๊ฑฐ๋‚˜ ์ ์€ ๋น„ํŠธ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •๋ฐ€๋„์— ์˜ํ–ฅ์„ ์ค๋‹ˆ๋‹ค.

C++๋Š” ์œ„์—์„œ ๋…ผ์˜ํ•œ ๊ธฐ๋ณธ ์œ ํ˜•์„ ๊ธฐ๋ฐ˜์œผ๋กœ ๋‹ค์–‘ํ•œ ์œ ํ˜•์„ ์ง€์›ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๋‹ค๋ฅธ ์œ ํ˜•์„ ๋ณตํ•ฉ ๋ฐ์ดํ„ฐ ์œ ํ˜• ์ด๋ผ๊ณ  ํ•˜๋ฉฐ C++ ์–ธ์–ด์˜ ์ฃผ์š” ๊ฐ•์  ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค. ์šฐ๋ฆฌ๋Š” ๋˜ํ•œ ๋‹ค์Œ ์žฅ์—์„œ ๋” ์ž์„ธํžˆ ๋ณผ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

 

๋ณ€์ˆ˜ ์„ ์–ธ

C++๋Š” ๊ฐ•๋ ฅํ•œ ํ˜•์‹์˜ ์–ธ์–ด์ด๋ฉฐ ๋ชจ๋“  ๋ณ€์ˆ˜๋ฅผ ์ฒ˜์Œ ์‚ฌ์šฉํ•˜๊ธฐ ์ „์— ํ•ด๋‹น ํ˜•์‹์œผ๋กœ ์„ ์–ธํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ๋ณ€์ˆ˜์— ๋Œ€ํ•ด ๋ฉ”๋ชจ๋ฆฌ์— ์˜ˆ์•ฝํ•  ํฌ๊ธฐ์™€ ํ•ด๋‹น ๊ฐ’์„ ํ•ด์„ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์ปดํŒŒ์ผ๋Ÿฌ์— ์•Œ๋ ค์ค๋‹ˆ๋‹ค. C++์—์„œ ์ƒˆ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๋Š” ๊ตฌ๋ฌธ์€ ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค. ์œ ํ˜• ๋‹ค์Œ์— ๋ณ€์ˆ˜ ์ด๋ฆ„(์ฆ‰, ํ•ด๋‹น ์‹๋ณ„์ž)์„ ์ž‘์„ฑํ•˜๊ธฐ๋งŒ ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. 

int a;
float mynumber;

์ด๊ฒƒ์€ ๋‘ ๊ฐ€์ง€ ๋ณ€์ˆ˜ ์„ ์–ธ์ž…๋‹ˆ๋‹ค. ์ฒซ ๋ฒˆ์งธ a๋Š” int ์‹๋ณ„์ž๊ฐ€ ์žˆ๋Š” ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค. ๋‘ ๋ฒˆ์งธ mynumber๋Š” float ์‹๋ณ„์ž๊ฐ€ ์žˆ๋Š” ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค. ์ผ๋‹จ ์„ ์–ธ๋˜๋ฉด ๋ณ€์ˆ˜ a๋ฐ mynumberํ”„๋กœ๊ทธ๋žจ์˜ ๋‚˜๋จธ์ง€ ๋ฒ”์œ„ ๋‚ด์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


๋™์ผํ•œ ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋ฅผ ๋‘˜ ์ด์ƒ ์„ ์–ธํ•˜๋Š” ๊ฒฝ์šฐ ์‹๋ณ„์ž๋ฅผ ์‰ผํ‘œ๋กœ ๊ตฌ๋ถ„ํ•˜์—ฌ ๋‹จ์ผ ๋ช…๋ น๋ฌธ์—์„œ ๋ชจ๋‘ ์„ ์–ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

int a, b, c;

์ด๊ฒƒ์€ ์„ธ ๊ฐœ์˜ ๋ณ€์ˆ˜( a, b๋ฐ c)๋ฅผ ์„ ์–ธํ•˜๊ณ  ๋ชจ๋‘ ์œ ํ˜• int์ด๋ฉฐ ๋‹ค์Œ๊ณผ ์ •ํ™•ํžˆ ๊ฐ™์€ ์˜๋ฏธ๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค.

int a;
int b;
int c;

ํ”„๋กœ๊ทธ๋žจ ๋‚ด์—์„œ ๋ณ€์ˆ˜ ์„ ์–ธ์ด ์–ด๋–ป๊ฒŒ ์ž‘๋™ํ•˜๋Š”์ง€ ๋ณด๊ธฐ ์œ„ํ•ด ์ด ์žฅ์˜ ์‹œ์ž‘ ๋ถ€๋ถ„์—์„œ ์ œ์•ˆํ•œ ์ •์‹  ๊ธฐ์–ต์— ๋Œ€ํ•œ ์˜ˆ์ œ์˜ ์ „์ฒด C++ ์ฝ”๋“œ๋ฅผ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

// operating with variables

#include <iostream>
using namespace std;

int main ()
{
  // declaring variables:
  int a, b;
  int result;

  // process:
  a = 5;
  b = 2;
  a = a + 1;
  result = a - b;

  // print out the result:
  cout << result;

  // terminate the program:
  return 0;
}

 

 

๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™”

์œ„์˜ ์˜ˆ์—์„œ ๋ณ€์ˆ˜๊ฐ€ ์„ ์–ธ๋˜๋ฉด ์ฒ˜์Œ ๊ฐ’์ด ํ• ๋‹น๋  ๋•Œ๊นŒ์ง€ ๋ฏธ์ •์˜ ๊ฐ’์„ ๊ฐ€์ง‘๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ณ€์ˆ˜๋Š” ์„ ์–ธ๋œ ์ˆœ๊ฐ„๋ถ€ํ„ฐ ํŠน์ • ๊ฐ’์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์„ ๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™” ๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

C++์—์„œ๋Š” ๋ณ€์ˆ˜๋ฅผ ์ดˆ๊ธฐํ™”ํ•˜๋Š” ์„ธ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค. 

์ฒซ ๋ฒˆ์งธ ์ดˆ๊ธฐํ™” ๋Š” ๋“ฑํ˜ธ ๋’ค์— ๊ฐ’์„ ์ถ”๊ฐ€ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ๊ตฌ์„ฑ๋ฉ๋‹ˆ๋‹ค

type identifier = initial_value;

int x์„ ์–ธ๋œ ์ˆœ๊ฐ„๋ถ€ํ„ฐ 0 ๊ฐ’์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

int x = 0;โ€‹



์ƒ์„ฑ์ž ์ดˆ๊ธฐํ™” (C++ ์–ธ์–ด์—์„œ ๋„์ž…) ๋กœ ์•Œ๋ ค์ง„ ๋‘ ๋ฒˆ์งธ ๋ฐฉ๋ฒ• ์€ ์ดˆ๊ธฐ ๊ฐ’์„ ๊ด„ํ˜ธ( )๋กœ ๋ฌถ์Šต๋‹ˆ๋‹ค.

type identifier (initial_value);
์˜ˆ๋ฅผ ๋“ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

Int x (0);


๋งˆ์ง€๋ง‰์œผ๋กœ, ๊ท ์ผ ์ดˆ๊ธฐํ™” ๋กœ ์•Œ๋ ค์ง„ ์„ธ ๋ฒˆ์งธ ๋ฐฉ๋ฒ• ์€ ์œ„์™€ ์œ ์‚ฌํ•˜์ง€๋งŒ ๊ด„ํ˜ธ ๋Œ€์‹  ์ค‘๊ด„ํ˜ธ( {})๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค(์ด๋Š” 2011๋…„ C++ ํ‘œ์ค€ ๊ฐœ์ •ํŒ์— ๋„์ž…๋จ).

type identifier {initial_value};
์˜ˆ๋ฅผ ๋“ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

int x {0};

๋ณ€์ˆ˜๋ฅผ ์ดˆ๊ธฐํ™”ํ•˜๋Š” ์„ธ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์€ ๋ชจ๋‘ C++์—์„œ ์œ ํšจํ•˜๊ณ  ๋™๋“ฑํ•ฉ๋‹ˆ๋‹ค.

// initialization of variables

#include <iostream>
using namespace std;

int main ()
{
  int a=5;               // initial value: 5
  int b(3);              // initial value: 3
  int c{2};              // initial value: 2
  int result;            // initial value undetermined

  a = a + b;
  result = a - c;
  cout << result;

  return 0;
}
auto ๋ฐ decltype

์ƒˆ ๋ณ€์ˆ˜๊ฐ€ ์ƒ์„ฑ ๋ ๋•Œ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ํ”„๋กœ๊ทธ๋žจ์—์„œ ์ž๋™์œผ๋กœ ๋ณ€์ˆ˜์˜ ์œ ํ˜•์„ ํŒŒ์•…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

int foo = 0;
auto bar = foo;  // the same as: int bar = foo;

Bar ์œ ํ˜•์€ foo์˜ intํ˜•์„ ๋”ฐ๋ผ์„œ ์ž๋™์œผ๋กœ intํ˜•์œผ๋กœ ์„ ์–ธ์ด ๋ฉ๋‹ˆ๋‹ค.



์ดˆ๊ธฐํ™”๋˜์ง€ ์•Š์€ ๋ณ€์ˆ˜๋Š” decltype์ง€์ •์ž์™€ ํ•จ๊ป˜ ์œ ํ˜• ์ถ”๋ก ์„ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

int foo = 0;
decltype(foo) bar;  // the same as: int bar;
 

bar๋Š” foo์™€ ๊ฐ™์€ ํƒ€์ž…์œผ๋กœ ์„ ์–ธ๋ฉ๋‹ˆ๋‹ค. decltype์€ ์ตœ๊ทผ์— ์–ธ์–ด์— ์ถ”๊ฐ€๋œ ๊ฐ•๋ ฅํ•œ ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค

auto. decltype์€ ์ž์ฃผ ์‚ฌ์šฉ๋˜์ง€๋Š” ์•Š์ง€๋งŒ ๋•Œ๋•Œ๋กœ ์ฝ”๋“œ์˜ ๊ฐ€๋…์„ฑ์„ ๋†’์ด๊ธฐ ์œ„ํ•ด์„œ

์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์Šต๋‹ˆ๋‹ค.

 

๋ฌธ์ž์—ด ํด๋ž˜์Šค ์†Œ๊ฐœ

C++ ์–ธ์–ด์˜ ์ฃผ์š” ์žฅ์  ์ค‘ ํ•˜๋‚˜๋Š” ์—ฌ๋Ÿฌ๊ฐ€์ง€ ์ด๋ฏธ ๋งŒ๋“ค์–ด์ง„ class ์œ ํ˜•๋“ค์„ ์‚ฌ์šฉํ• ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด๋Ÿฌํ•œ ์œ ํ˜•์˜ ์˜ˆ๋Š” stringํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค. ์ด ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋Š” ๋‹จ์–ด๋‚˜ ๋ฌธ์žฅ๊ณผ ๊ฐ™์€ ์ผ๋ จ์˜ ๋ฌธ์ž๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋งค์šฐ ์œ ์šฉํ•œ ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค!

๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ์œ ํ˜•๊ณผ์˜ ์ฒซ ๋ฒˆ์งธ ์ฐจ์ด์ ์€ ์ด ์œ ํ˜•์˜ ๊ฐ์ฒด(๋ณ€์ˆ˜)๋ฅผ ์„ ์–ธํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋ ค๋ฉด ํ”„๋กœ๊ทธ๋žจ์ด ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ(header <string>) ๋‚ด์—์„œ ์œ ํ˜•์ด ์ •์˜๋œ ํ—ค๋”๋ฅผ ํฌํ•จํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

// my first string
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string mystring;
  mystring = "This is a string";
  cout << mystring;
  return 0;
}

์ด์ „ ์˜ˆ์ œ์—์„œ ๋ณผ ์ˆ˜ ์žˆ๋“ฏ์ด ์ˆซ์ž ์œ ํ˜• ๋ณ€์ˆ˜๊ฐ€ ์œ ํšจํ•œ ์ˆซ์ž ๋ฆฌํ„ฐ๋Ÿด๋กœ ์ดˆ๊ธฐํ™”๋  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ฌธ์ž์—ด์€ ์œ ํšจํ•œ ๋ฌธ์ž์—ด ๋ฆฌํ„ฐ๋Ÿด๋กœ ์ดˆ๊ธฐํ™”๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ธฐ๋ณธ ์œ ํ˜•๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ชจ๋“  ์ดˆ๊ธฐํ™” ํ˜•์‹์€ string์—์„œ๋„ ์œ ํšจํ•ฉ๋‹ˆ๋‹ค.

 

string mystring = "This is a string";
string mystring ("This is a string");
string mystring {"This is a string"};

String์€ ๋˜ํ•œ ์ดˆ๊ธฐ ๊ฐ’ ์—†์ด ์„ ์–ธ๋˜๊ณ  ์‹คํ–‰ ์ค‘์— ๊ฐ’์„ ๋ณ€๊ฒฝํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™์ด ๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์ด ํ•  ์ˆ˜ ์žˆ๋Š” ๋‹ค๋ฅธ ๋ชจ๋“  ๊ธฐ๋ณธ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

// my first string
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string mystring;
  mystring = "This is the initial string content";
  cout << mystring << endl;
  mystring = "This is a different string content";
  cout << mystring << endl;
  return 0;
}

string ํด๋ž˜์Šค๋Š” ๋ณตํ•ฉ ์œ ํ˜• ์ž…๋‹ˆ๋‹ค. ์œ„์˜ ์˜ˆ์—์„œ ๋ณผ ์ˆ˜ ์žˆ๋“ฏ์ด ๋ณตํ•ฉ ์œ ํ˜• ์€ ๊ธฐ๋ณธ ์œ ํ˜• ๊ณผ ๋™์ผํ•œ ๋ฐฉ์‹์œผ๋กœ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค . ๋™์ผํ•œ ๊ตฌ๋ฌธ์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ณ  ์ดˆ๊ธฐํ™”ํ•ฉ๋‹ˆ๋‹ค.

๋Œ“๊ธ€