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

๋ช…๋ น๋ฌธ ๋ฐ ํ๋ฆ„ ์ œ์–ด

by eazuooz 2022. 8. 18.

๊ฐ„๋‹จํ•œ C++ ๋ฌธ์€ ์ด์ „ ์„น์…˜์—์„œ ๋ณธ ๋ณ€์ˆ˜ ์„ ์–ธ ๋ฐ ํ‘œํ˜„์‹๊ณผ ๊ฐ™์€ ํ”„๋กœ๊ทธ๋žจ์˜ ๊ฐœ๋ณ„๋ช…๋ น์–ด๋Š” ํ•ญ์ƒ ์„ธ๋ฏธ์ฝœ๋ก ( ;)์œผ๋กœ ๋๋‚ฉ๋‹ˆ๋‹ค.



๊ทธ๋Ÿฌ๋‚˜ ํ”„๋กœ๊ทธ๋žจ์€ ์„ ํ˜•์ ์œผ๋กœ ํ•˜๋‚˜์˜ ๋ถ„๊ธฐ๋กœ๋งŒ ์‹คํ–‰๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ฝ”๋“œ๋ฅผ ๋ฐ˜๋ณตํ•˜๊ฑฐ๋‚˜ ๋˜๋Š” ์—ฌ๋Ÿฌ ๋ถ„๊ธฐ๋กœ ๋‚˜๋ˆŒ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ์œ„ํ•ด C++๋Š” ์šฐ๋ฆฌ ํ”„๋กœ๊ทธ๋žจ์ด ์–ธ์ œ, ์–ด๋–ค ์ƒํ™ฉ์—์„œ ๋ฌด์—‡์„ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•˜๋Š”์ง€ ์ง€์ •ํ•˜๋Š” ์—ญํ• ์„ ํ•˜๋Š” ์ œ์–ด ๋ฌธ์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.

์กฐ๊ฑด ๋ฌธ: if ๋ฐ else

 

ํ‚ค์›Œ๋“œ๋Š” ์กฐ๊ฑด ์ด if์ถฉ์กฑ๋˜๋Š” ๊ฒฝ์šฐ์—๋งŒ ๋ช…๋ น๋ฌธ์ด๋‚˜ ๋ธ”๋ก์„ ์‹คํ–‰ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๊ตฌ๋ฌธ์€ ๋‹ค์Œ ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

if (condition)

    statement

 

condition ์กฐ๊ฑด์ด ์ฐธ์ด๋ผ๋ฉด ์กฐ๊ฑด๋ฌธ ๋ฐ‘์—์ค„์— ํ•ด๋‹นํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค.



if (x == 100)
  cout << "x is 100";โ€‹



x์ •ํ™•ํžˆ 100์ด ์•„๋‹ˆ๋ฉด ์ด ๋ช…๋ น๋ฌธ์€ ๋ฌด์‹œ๋˜๊ณ  ์•„๋ฌด ๊ฒƒ๋„ ์ธ์‡„๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค .

์กฐ๊ฑด์ด ์ถฉ์กฑ๋  ๋•Œ ์‹คํ–‰ํ•  ํ•˜๋‚˜ ์ด์ƒ์˜ ๋ช…๋ น๋ฌธ์„ ํฌํ•จํ•˜๋ ค๋ฉด ์ด๋Ÿฌํ•œ ๋ช…๋ น๋ฌธ์„ ์ค‘๊ด„ํ˜ธ( {})๋กœ ๋ฌถ์–ด ๋ธ”๋ก์„ ํ˜•์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

if (x == 100)
{
   cout << "x is ";
   cout << x;
}
 



ํ‰์†Œ์™€ ๊ฐ™์ด ์ฝ”๋“œ์˜ ๋“ค์—ฌ์“ฐ๊ธฐ์™€ ์ค„ ๋ฐ”๊ฟˆ์€ ์˜ํ–ฅ์„ ๋ฏธ์น˜์ง€ ์•Š์œผ๋ฏ€๋กœ ์œ„์˜ ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

if (x == 100) { cout << "x is "; cout << x; }
 



Else ๊ตฌ๋ฌธ์€ if ๊ตฌ๋ฌธ์ด ์ฐธ์ด์ง€ ์•Š์„ ๊ฒฝ์šฐ์— ์‹คํ–‰ ๋ฉ๋‹ˆ๋‹ค.


if (condition) statement1 else statement2
statement1statement2

if (x == 100)
  cout << "x is 100";
else
  cout << "x is not 100";



 



์ด๊ฒƒ์€ x is 100x๊ฐ€ ์‹ค์ œ๋กœ 100์˜ ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์žˆ์œผ๋ฉด ๋ฅผ ์ธ์‡„ํ•˜์ง€๋งŒ, ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ์—๋งŒ x is not 100๋Œ€์‹  ์ธ์‡„ํ•ฉ๋‹ˆ๋‹ค.
๊ฐ’ ๋ฒ”์œ„๋ฅผ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด ์—ฌ๋Ÿฌ if + else ๊ตฌ์กฐ๋ฅผ ์—ฐ๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

if (x > 0)
  cout << "x is positive";
else if (x < 0)
  cout << "x is negative";
else
  cout << "x is 0";
 

์ˆœ์„œ๋Œ€๋กœ if๋ฌธ์˜ ์กฐ๊ฑด์„ ํ™•์ธํ•˜๊ณ  ์ฐธ์ด๋˜๋Š” ์กฐ๊ฑด์ด ์—†๋‹ค๋ฉด else๋ฌธ์„ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค.

 

๋ฐ˜๋ณต๋ฌธ(๋ฃจํ”„)

๋ฃจํ”„๋Š” ํŠน์ • ํšŸ์ˆ˜ ๋˜๋Š” ์กฐ๊ฑด์ด ์ถฉ์กฑ๋˜๋Š” ๋™์•ˆ ๋ช…๋ น๋ฌธ์„ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค. while, do, for ๋ฐ ํ‚ค์›Œ๋“œ๋กœ ์‹œ์ž‘๋ฉ๋‹ˆ๋‹ค.

While๋ฌธ

๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ์ข…๋ฅ˜์˜ ๋ฃจํ”„๋Š” while ๋ฃจํ”„์ž…๋‹ˆ๋‹ค๊ตฌ๋ฌธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค . while ๋ฃจํ”„๋Š” ์กฐ๊ฑด์ด true ์ธ ๋™์•ˆ ๋‹จ์ˆœํžˆ ๋ฐ˜๋ณต ํ•ฉ๋‹ˆ๋‹ค์‹คํ–‰ ํ›„ ๋” ์ด์ƒ true๊ฐ€ ์•„๋‹Œ ๊ฒฝ์šฐ ๋ฃจํ”„๊ฐ€ ์ข…๋ฃŒ๋˜๊ณ  ์‹คํ–‰ ๋ถ„๊ธฐ๋Š” ๋ฃจํ”„ ๋ฐ”๋กœ ๋’ค์— ๊ณ„์†๋ฉ๋‹ˆ๋‹ค์˜ˆ๋ฅผ ๋“ค์–ด while ๋ฃจํ”„๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ์นด์šดํŠธ๋‹ค์šด์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

// custom countdown using while
#include <iostream>
using namespace std;

int main ()
{
  int n = 10;

  while (n>0) {
    cout << n << ", ";
    --n;
  }

  cout << "liftoff!\n";
}โ€‹
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ์ด๋ฅ™!
์˜ ์ฒซ ๋ฒˆ์งธ ๋ช…๋ น๋ฌธ main์€ n ์„ ๊ฐ’ 10์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ์นด์šดํŠธ๋‹ค์šด์˜ ์ฒซ ๋ฒˆ์งธ ์ˆซ์ž์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ while ๋ฃจํ”„๊ฐ€ ์‹œ์ž‘๋ฉ๋‹ˆ๋‹ค. ์ด ๊ฐ’์ด ์กฐ๊ฑด n>0( n ์ด 0๋ณด๋‹ค ํผ)์„ ์ถฉ์กฑํ•˜๋ฉด ์กฐ๊ฑด์„ ๋”ฐ๋ฅด๋Š” ๋ธ”๋ก์ด ์‹คํ–‰๋˜๊ณ  ์กฐ๊ฑด( n>0)์ด ์ฐธ์ธ ๋™์•ˆ ๋ฐ˜๋ณต๋ฉ๋‹ˆ๋‹ค.
  1. n๊ฐ’์ด ํ• ๋‹น๋ฉ๋‹ˆ๋‹ค
  2. while์กฐ๊ฑด์„ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค( ) n>0. ์ด ์‹œ์ ์—์„œ ๋‘ ๊ฐ€์ง€ ๊ฐ€๋Šฅ์„ฑ์ด ์žˆ์Šต๋‹ˆ๋‹ค.
    • ์กฐ๊ฑด์ด ์ฐธ: ๋ช…๋ น๋ฌธ์ด ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค
    • ์กฐ๊ฑด์ด ๊ฑฐ์ง“: While๋ฌธ์„ ํƒˆ์ถœํ•ฉ๋‹ˆ๋‹ค.
  3. ๋‚ด๋ถ€ ์ฝ”๋“œ๋ฅผ ์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค.
  4. ๋ธ”๋ก ๋. ์ž๋™์œผ๋กœ 2๋‹จ๊ณ„๋กœ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค.

while ๋ฃจํ”„์—์„œ ๊ณ ๋ คํ•ด์•ผ ํ•  ์‚ฌํ•ญ์€ ๋ฃจํ”„๊ฐ€ ํŠน์ • ์ง€์ ์—์„œ ๋๋‚˜์•ผ ํ•˜๋ฏ€๋กœ ๋ช…๋ น๋ฌธ์ด ์กฐ๊ฑด์—์„œ ํ™•์ธ๋œ ๊ฐ’์„ ์–ด๋–ค ๋ฐฉ์‹์œผ๋กœ๋“  ๋ณ€๊ฒฝํ•˜์—ฌ ํŠน์ • ์ง€์ ์—์„œ ๊ฐ•์ œ๋กœ ๊ฑฐ์ง“์ด ๋˜๋„๋ก ํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ๋ฃจํ”„๊ฐ€ ๊ณ„์† ๋ฐ˜๋ณต๋ฉ๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ ๋ฃจํ”„๋Š” --n์กฐ๊ฑด( )์—์„œ ํ‰๊ฐ€๋˜๋Š” ๋ณ€์ˆ˜์˜ ๊ฐ’์„ 1๋งŒํผ ์ค„์ด๋Š” ๋ฅผ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค . ์ด๋Š” ํŠน์ • ๋ฃจํ”„ ๋ฐ˜๋ณต ํ›„์— n๊ฒฐ๊ตญ ์กฐ๊ฑด( )์„ false๋กœ ๋งŒ๋“ญ๋‹ˆ๋‹ค . n>0๋” ๊ตฌ์ฒด์ ์œผ๋กœ ๋งํ•˜๋ฉด 10๋ฒˆ์˜ ๋ฐ˜๋ณต ํ›„์— n๋Š” 0์ด ๋˜์–ด ์กฐ๊ฑด์ด ๋” ์ด์ƒ ์ฐธ์ด ๋˜์ง€ ์•Š๊ณ  while ๋ฃจํ”„๊ฐ€ ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.
do-while ๋ฃจํ”„
๋งค์šฐ ์œ ์‚ฌํ•œ ๋ฃจํ”„๋Š” do-while ๋ฃจํ”„๋กœ, ๊ตฌ๋ฌธ์€ ๋‹ค์Œ ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์ด ๋ฃจํ”„๋Š” ์ด์ „ ๋Œ€์‹  ์˜ ์‹คํ–‰ ํ›„์— ํ‰๊ฐ€ ๋œ๋‹ค๋Š” ์ ์„ ์ œ์™ธํ•˜๊ณ ๋Š” while ๋ฃจํ”„์ฒ˜๋Ÿผ ๋™์ž‘ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฃจํ”„๋Š” ๊ฐ€ ์ˆ˜ํ–‰๋˜์ง€ ์•Š๋”๋ผ๋„ ์ตœ์†Œํ•œ ํ•œ ๋ฒˆ์€ ์˜ ์‹คํ–‰์„ ๋ณด์žฅ ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋‹ค์Œ ์˜ˆ์ œ ํ”„๋กœ๊ทธ๋žจ์€ ์‚ฌ์šฉ์ž๊ฐ€ ์ž‘๋ณ„ ์ธ์‚ฌ๋ฅผ ์ž…๋ ฅํ•  ๋•Œ๊นŒ์ง€ ์‚ฌ์šฉ์ž๊ฐ€ ์†Œ๊ฐœํ•˜๋Š” ๋ชจ๋“  ํ…์ŠคํŠธ๋ฅผ ์—์ฝ”ํ•ฉ๋‹ˆ๋‹ค.
// echo machine
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string str;
  do {
    cout << "Enter text: ";
    getline (cin,str);
    cout << "You entered: " << str << '\n';
  } while (str != "goodbye");
}
ํ…์ŠคํŠธ ์ž…๋ ฅ: ์•ˆ๋…•ํ•˜์„ธ์š”
๋‹น์‹ ์€ ์ž…๋ ฅ: ์•ˆ๋…•ํ•˜์„ธ์š”
ํ…์ŠคํŠธ ์ž…๋ ฅ: ๊ฑฐ๊ธฐ ๋ˆ„๊ตฌ์„ธ์š”?
๋‹น์‹ ์ด ์ž…๋ ฅํ–ˆ์Šต๋‹ˆ๋‹ค : ๊ฑฐ๊ธฐ์— ๋ˆ„๊ตฌ์ž…๋‹ˆ๊นŒ?
ํ…์ŠคํŠธ ์ž…๋ ฅ: ์•ˆ๋…•
๋‹น์‹ ์€ ์ž…๋ ฅ: ์•ˆ๋…•

 

for ๋ฃจํ”„

for๋ฃจํ”„๋Š” ์—ฌ๋Ÿฌ ๋ฒˆ ๋ฐ˜๋ณตํ•˜๋„๋ก ์„ค๊ณ„๋˜์—ˆ์Šต๋‹ˆ๋‹ค . ๊ตฌ๋ฌธ์€ ๋‹ค์Œ ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค . while ๋ฃจํ”„์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ด ๋ฃจํ”„ ๋Š” true ์ธ ๋™์•ˆ ๋ฐ˜๋ณต๋ฉ๋‹ˆ๋‹ค๋”ฐ๋ผ์„œ ์‹œ์ž‘๋ถ€ํ„ฐ ๋์ด ์กด์žฌํ•˜๋Š” ๋ฐ˜๋ณต๋กœ์ง์— ์ด์šฉํ•˜๋Š” ๊ฒƒ์ด ์œ ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.



for (initialization; condition; increase) statement;
  1. initialization์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ ์ด๊ฒƒ์€ ์นด์šดํ„ฐ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ณ  ์ดˆ๊ธฐ ๊ฐ’์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ๋ฃจํ”„์˜ ์‹œ์ž‘ ๋ถ€๋ถ„์—์„œ ํ•œ ๋ฒˆ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค.
  2. ์กฐ๊ฑด์„ ํ™•์ธ ํ•ฉ๋‹ˆ๋‹ค.  ์ฐธ์ด๋ฉด ๋ฃจํ”„๊ฐ€ ๊ณ„์†๋ฉ๋‹ˆ๋‹ค๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ๋ฃจํ”„๊ฐ€ ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.
  3. statement์‹คํ–‰๋ฉ๋‹ˆ๋‹ค. ํ‰์†Œ์™€ ๊ฐ™์ด ๋‹จ์ผ ๋ฌธ์ด๊ฑฐ๋‚˜ ์ค‘๊ด„ํ˜ธ๋กœ ๋ฌถ์ธ ๋ธ”๋ก์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค { }.
  4. increase์‹คํ–‰๋˜๊ณ  ๋ฃจํ”„๋Š” 2๋‹จ๊ณ„๋กœ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค.
  5. ๋ฃจํ”„๊ฐ€ ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค. ์‹คํ–‰์€ ๊ทธ ๋’ค์˜ ๋‹ค์Œ ๋ช…๋ น๋ฌธ์— ์˜ํ•ด ๊ณ„์†๋ฉ๋‹ˆ๋‹ค.


๋‹ค์Œ์€ for ๋ฃจํ”„๋ฅผ ์‚ฌ์šฉํ•œ ์นด์šดํŠธ๋‹ค์šด ์˜ˆ์ž…๋‹ˆ๋‹ค.

// countdown using a for loop
#include <iostream>
using namespace std;

int main ()
{
  for (int n=10; n>0; n--) {
    cout << n << ", ";
  }
  cout << "liftoff!\n";
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ์ด๋ฅ™!

for ๋ฃจํ”„์˜ ์„ธ ํ•„๋“œ๋Š” ์„ ํƒ ์‚ฌํ•ญ์ž…๋‹ˆ๋‹ค๋น„์›Œ ๋‘˜ ์ˆ˜ ์žˆ์ง€๋งŒ ๋ชจ๋“  ๊ฒฝ์šฐ์— ๊ทธ ์‚ฌ์ด์— ์„ธ๋ฏธ์ฝœ๋ก  ๊ธฐํ˜ธ๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค์˜ˆ๋ฅผ ๋“ค์–ด์ดˆ๊ธฐํ™” ๋˜๋Š” ์ฆ๊ฐ€for (;n<10;) ๊ฐ€ ์—†๋Š” ๋ฃจํ”„์ž…๋‹ˆ๋‹ค (while ๋ฃจํ”„์™€ ๋™์ผ)  ์กฐ๊ฑด์ด ์—†๋Š” ๋ฃจํ”„๋Š” ์กฐ๊ฑด ์ด ์žˆ๋Š” ๋ฃจํ”„ (์ฆ‰, ๋ฌดํ•œ ๋ฃจํ”„)์™€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค

 

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

for ( n=0, i=100 ; n!=i ; ++n, --i )
{
   // whatever here...
}

์ด ๋ฃจํ”„๋Š” ๋ฃจํ”„ ๋‚ด์—์„œ n๋˜๋Š” ๋‘˜ ๋‹ค ์ˆ˜์ •๋˜์ง€ ์•Š์€ ๊ฒฝ์šฐ 50๋ฒˆ ์‹คํ–‰ ๋ฉ๋‹ˆ๋‹ค. ๊ฐ’์ด 0์œผ๋กœ ์‹œ์ž‘ํ•˜๊ณ  100์ด๋ฉด ์กฐ๊ฑด์ด (์ฆ‰, ๊ฐ™์ง€ ์•Š์Œ )์ž…๋‹ˆ๋‹ค. ๊ฐ ๋ฐ˜๋ณต๋งˆ๋‹ค 1 ์”ฉ ์ฆ๊ฐ€ํ•˜๊ณ  1์”ฉ ๊ฐ์†Œ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฃจํ”„์˜ ์กฐ๊ฑด์€ 50ํšŒ ๋ฐ˜๋ณต ํ›„์— ๊ฑฐ์ง“์ด ๋ฉ๋‹ˆ๋‹ค .

Ranged For ๋ฌธ

for ๋ฃจํ”„์—๋Š” ๋ฒ”์œ„์—๋งŒ ์‚ฌ์šฉ๋˜๋Š” ๋˜ ๋‹ค๋ฅธ ๊ตฌ๋ฌธ์ด ์žˆ์Šต๋‹ˆ๋‹ค์ด๋Ÿฌํ•œ ์ข…๋ฅ˜์˜ for ๋ฃจํ”„๋Š” ์˜ ๋ชจ๋“  ์š”์†Œ๋ฅผ โ€‹โ€‹๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค . ์—ฌ๊ธฐ์„œ ์ด ๋ฒ”์œ„์˜ ์š”์†Œ ๊ฐ’์„ ์ทจํ•  ์ˆ˜ ์žˆ๋Š” ์ผ๋ถ€ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค๋ฒ”์œ„๋Š” ๋ฐฐ์—ด, ์ปจํ…Œ์ด๋„ˆ ๋ฐ ๊ธฐ๋Šฅ์„ ์ง€์›ํ•˜๋Š” ๊ธฐํƒ€ ์œ ํ˜•์„ ๋ชจ๋‘ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค.



for ( declaration : range ) statement;

๋ฌธ์ž์—ด์„ ์‚ฌ์šฉํ•˜๋Š” ๋ฒ”์œ„ ๊ธฐ๋ฐ˜ for ๋ฃจํ”„์˜ ์˜ˆ:

// range-based for loop
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string str {"Hello!"};
  for (char c : str)
  {
    cout << "[" << c << "]";
  }
  cout << '\n';
}
[Hello][!]

์ผ๋ฐ˜์ ์œผ๋กœ ์œ„์˜ ๋ฒ”์œ„ ๊ธฐ๋ฐ˜ ๋ฃจํ”„๋Š” auto์™€ ๊ฐ™์ด ์ž‘์„ฑํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

for (auto c : str)
  cout << "[" << c << "]";

์—ฌ๊ธฐ์„œ c์˜ ์œ ํ˜•์€ ์˜ ์š”์†Œ ์œ ํ˜•์œผ๋กœ ์ž๋™ ์ถ”๋ก ๋ฉ๋‹ˆ๋‹ค

 

์ ํ”„ ๋ฌธ

์ ํ”„ ๋ฌธ์„ ์‚ฌ์šฉํ•˜๋ฉด ํŠน์ • ์œ„์น˜๋กœ ์ ํ”„๋ฅผ ์ˆ˜ํ–‰ํ•˜์—ฌ ํ”„๋กœ๊ทธ๋žจ์˜ ํ๋ฆ„์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

break ๋ฌธ

break์ข…๋ฃŒ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋˜์ง€ ์•Š๋”๋ผ๋„ ๋ฃจํ”„๋ฅผ ๋– ๋‚ฉ๋‹ˆ๋‹ค. ๋ฌดํ•œ ๋ฃจํ”„๋ฅผ ์ข…๋ฃŒํ•˜๊ฑฐ๋‚˜ ์ž์—ฐ ์ข…๋ฃŒ ์ „์— ๊ฐ•์ œ๋กœ ์ข…๋ฃŒํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ์ž์—ฐ ์ข…๋ฃŒ๋˜๊ธฐ ์ „์— ์นด์šดํŠธ๋‹ค์šด์„ ์ค‘์ง€ํ•ฉ์‹œ๋‹ค.
// break loop example
#include <iostream>
using namespace std;

int main ()
{
  for (int n=10; n>0; n--)
  {
    cout << n << ", ";
    if (n==3)
    {
      cout << "countdown aborted!";
      break;
    }
  }
}
10, 9, 8, 7, 6, 5, 4, 3, ์นด์šดํŠธ๋‹ค์šด์ด ์ค‘๋‹จ๋˜์—ˆ์Šต๋‹ˆ๋‹ค!

Continue ๋ฌธ

๋ช…๋ น๋ฌธ์€ ํ”„๋กœ๊ทธ๋žจ ์ด continue๋ช…๋ น๋ฌธ ๋ธ”๋ก์˜ ๋์— ๋„๋‹ฌํ•œ ๊ฒƒ์ฒ˜๋Ÿผ ํ˜„์žฌ ๋ฐ˜๋ณต์—์„œ ๋‚˜๋จธ์ง€ ๋ฃจํ”„๋ฅผ ๊ฑด๋„ˆ๋›ฐ๊ฒŒ ํ•˜์—ฌ ๋‹ค์Œ ๋ฐ˜๋ณต์˜ ์‹œ์ž‘ ๋ถ€๋ถ„์œผ๋กœ ์ ํ”„ํ•˜๋„๋ก ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ์นด์šดํŠธ๋‹ค์šด์—์„œ 5๋ฒˆ์„ ๊ฑด๋„ˆ๋›ฐ์ž.

// continue loop example
#include <iostream>
using namespace std;

int main ()
{
  for (int n=10; n>0; n--) {
    if (n==5) continue;
    cout << n << ", ";
  }
  cout << "liftoff!\n";
}
10, 9, 8, 7, 6, 4, 3, 2, 1, ์ด๋ฅ™!

goto ๋ฌธ

gotoํ”„๋กœ๊ทธ๋žจ์˜ ๋‹ค๋ฅธ ์ง€์ ์œผ๋กœ ์‹คํ–‰๋ถ„๊ธฐ๋ฅผ ์›€์ง์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.  goto๋Š” ์ค‘์ฒฉ ์ˆ˜์ค€์„ ๋ฌด์‹œํ•˜๊ณ  ์ž๋™ ์Šคํƒ ํ•ด์ œ๋ฅผ ์ผ์œผํ‚ค์ง€ ์•Š์Šต๋‹ˆ๋‹ค๋”ฐ๋ผ์„œ ํŠนํžˆ ์ง€์—ญ ๋ณ€์ˆ˜๊ฐ€ ์žˆ๋Š” ๊ฒฝ์šฐ์—๋Š” ๋™์ผํ•œ ๋ฌธ ๋ธ”๋ก ๋‚ด์—์„œ ์ฃผ์˜ํ•ด์„œ ์‚ฌ์šฉํ•ด์•ผ ํ•˜๋Š” ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค.



๋ชฉ์ ์ง€ ์ง€์ ์€ ๋ ˆ์ด๋ธ” ๋กœ ์‹๋ณ„๋˜๋ฉฐ , ์ด๋Š” goto๋ช…๋ น๋ฌธ์˜ ์ธ์ˆ˜๋กœ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋ ˆ์ด๋ธ” ์€ ์œ ํšจํ•œ ์‹๋ณ„์ž์™€ ์ฝœ๋ก ( :)์œผ๋กœ ๊ตฌ์„ฑ๋ฉ๋‹ˆ๋‹ค.

goto๋Š” ์ผ๋ฐ˜์ ์œผ๋กœ C++์™€ ํ•จ๊ป˜ ์‚ฌ์šฉ๋˜๋Š” ์ตœ์‹  ๊ณ ๊ธ‰ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŒจ๋Ÿฌ๋‹ค์ž„์—์„œ ํŠน๋ณ„ํ•œ ์‚ฌ์šฉ ์‚ฌ๋ก€๊ฐ€ ์—†๋Š” ์ €์ˆ˜์ค€ ๊ธฐ๋Šฅ์œผ๋กœ ๊ฐ„์ฃผ๋ฉ๋‹ˆ๋‹ค๊ทธ๋Ÿฌ๋‚˜ ์˜ˆ๋ฅผ ๋“ค์–ด ๋‹ค์Œ์€ goto๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ์นด์šดํŠธ๋‹ค์šด ๋ฃจํ”„์˜ ๋ฒ„์ „์ž…๋‹ˆ๋‹ค.

// goto loop example
#include <iostream>
using namespace std;

int main ()
{
  int n=10;
mylabel:
  cout << n << ", ";
  n--;
  if (n>0) goto mylabel;
  cout << "liftoff!\n";
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ์ด๋ฅ™!

switch ๋ฌธ

switch ๋ฌธ์˜ ๊ตฌ๋ฌธ์€ ์•ฝ๊ฐ„ ๋…ํŠนํ•ฉ๋‹ˆ๋‹ค. ๊ทธ ๋ชฉ์ ์€ ๊ฐ€๋Šฅํ•œ ์—ฌ๋Ÿฌ ์ƒ์ˆ˜ ํ‘œํ˜„์‹ ์ค‘์—์„œ ๊ฐ’์„ ํ™•์ธํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. if- ๋ฌธ ์„ ์—ฐ๊ฒฐํ•˜๋Š” ๊ฒƒ๊ณผ ์œ ์‚ฌ elseํ•˜์ง€๋งŒ ์ƒ์ˆ˜ ํ‘œํ˜„์‹์œผ๋กœ ์ œํ•œ๋ฉ๋‹ˆ๋‹ค. ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ๊ตฌ๋ฌธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

switch (expression)
{
  case constant1:
     group-of-statements-1;
     break;
  case constant2:
     group-of-statements-2;
     break;
  .
  .
  .
  default:
     default-group-of-statements
}


Case๊ฐ€ ๊ฐ™์ง€ ์•Š์œผ๋ฉด constant1์— ๋Œ€ํ•ด ๊ฒ€์‚ฌ constant2๋ฉ๋‹ˆ๋‹ค์ด๊ฒƒ์ด ๊ฐ™์œผ๋ฉด ์Šค์œ„์น˜์˜ ๋์œผ๋กœ ์ ํ”„ํ•  ๋•Œ ๋ฐœ๊ฒฌ group-of-statements-2๋  ๋•Œ๊นŒ์ง€ ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค

default:

๋‹ค์Œ ์ฝ”๋“œ ์กฐ๊ฐ์€ ๋ชจ๋‘ ๋™์ผํ•œ ๋™์ž‘์„ ํ•˜๋ฉฐ if-else๊ฐ€ switch ๋ฌธ๊ณผ ๋™์ผํ•จ์„ ๋ณด์—ฌ์ค๋‹ˆ๋‹ค.

์Šค์œ„์น˜ ์˜ˆif-else ๋™๋“ฑ

switch (x) {
  case 1:
    cout << "x is 1";
    break;
  case 2:
    cout << "x is 2";
    break;
  default:
    cout << "value of x unknown";
  }
if (x == 1) {
  cout << "x is 1";
}
else if (x == 2) {
  cout << "x is 2";
}
else {
  cout << "value of x unknown";
}

Case ์—ฌ๋Ÿฌ ๊ฐœ๋ฅผ ํ•œ๋ฒˆ์— ํ•˜๋‚˜์˜ ์ฝ”๋“œ๋กœ๋„ ์ฒ˜๋ฆฌ๊ฐ€ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

switch (x) {
  case 1:
  case 2:
  case 3:
    cout << "x is 1, 2 or 3";
    break;
  default:
    cout << "x is not 1, 2 nor 3";
  }

 

'๐Ÿ“ Development Study > ๐Ÿ’ป Win32API' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

์˜ค๋ฒ„๋กœ๋”ฉ๊ณผ ํ…œํ”Œ๋ฆฟ  (0) 2022.08.18
ํ•จ์ˆ˜  (0) 2022.08.18
๊ธฐ๋ณธ ์ž…์ถœ๋ ฅ  (0) 2022.08.17
์—ฐ์‚ฐ์ž  (0) 2022.08.17
์ƒ์ˆ˜  (0) 2022.08.17

๋Œ“๊ธ€