๊ฐ๋จํ 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, ์ด๋ฅ!
- n๊ฐ์ด ํ ๋น๋ฉ๋๋ค
- while์กฐ๊ฑด์ ํ์ธํฉ๋๋ค( ) n>0. ์ด ์์ ์์ ๋ ๊ฐ์ง ๊ฐ๋ฅ์ฑ์ด ์์ต๋๋ค.
- ์กฐ๊ฑด์ด ์ฐธ: ๋ช ๋ น๋ฌธ์ด ์คํ๋ฉ๋๋ค
- ์กฐ๊ฑด์ด ๊ฑฐ์ง: While๋ฌธ์ ํ์ถํฉ๋๋ค.
- ๋ด๋ถ ์ฝ๋๋ฅผ ์์ฐจ์ ์ผ๋ก ์คํํฉ๋๋ค.
- ๋ธ๋ก ๋. ์๋์ผ๋ก 2๋จ๊ณ๋ก ๋์๊ฐ๋๋ค.
while ๋ฃจํ์์ ๊ณ ๋ คํด์ผ ํ ์ฌํญ์ ๋ฃจํ๊ฐ ํน์ ์ง์ ์์ ๋๋์ผ ํ๋ฏ๋ก ๋ช ๋ น๋ฌธ์ด ์กฐ๊ฑด์์ ํ์ธ๋ ๊ฐ์ ์ด๋ค ๋ฐฉ์์ผ๋ก๋ ๋ณ๊ฒฝํ์ฌ ํน์ ์ง์ ์์ ๊ฐ์ ๋ก ๊ฑฐ์ง์ด ๋๋๋ก ํด์ผ ํ๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ฃจํ๊ฐ ๊ณ์ ๋ฐ๋ณต๋ฉ๋๋ค. ์ด ๊ฒฝ์ฐ ๋ฃจํ๋ --n์กฐ๊ฑด( )์์ ํ๊ฐ๋๋ ๋ณ์์ ๊ฐ์ 1๋งํผ ์ค์ด๋ ๋ฅผ ํฌํจํฉ๋๋ค . ์ด๋ ํน์ ๋ฃจํ ๋ฐ๋ณต ํ์ n๊ฒฐ๊ตญ ์กฐ๊ฑด( )์ false๋ก ๋ง๋ญ๋๋ค . n>0๋ ๊ตฌ์ฒด์ ์ผ๋ก ๋งํ๋ฉด 10๋ฒ์ ๋ฐ๋ณต ํ์ n๋ 0์ด ๋์ด ์กฐ๊ฑด์ด ๋ ์ด์ ์ฐธ์ด ๋์ง ์๊ณ 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;
- initialization์คํ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด๊ฒ์ ์นด์ดํฐ ๋ณ์๋ฅผ ์ ์ธํ๊ณ ์ด๊ธฐ ๊ฐ์ผ๋ก ์ค์ ํฉ๋๋ค. ์ด๊ฒ์ ๋ฃจํ์ ์์ ๋ถ๋ถ์์ ํ ๋ฒ ์คํ๋ฉ๋๋ค.
- ์กฐ๊ฑด์ ํ์ธ ํฉ๋๋ค. ์ฐธ์ด๋ฉด ๋ฃจํ๊ฐ ๊ณ์๋ฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ฃจํ๊ฐ ์ข ๋ฃ๋ฉ๋๋ค.
- statement์คํ๋ฉ๋๋ค. ํ์์ ๊ฐ์ด ๋จ์ผ ๋ฌธ์ด๊ฑฐ๋ ์ค๊ดํธ๋ก ๋ฌถ์ธ ๋ธ๋ก์ผ ์ ์์ต๋๋ค { }.
- increase์คํ๋๊ณ ๋ฃจํ๋ 2๋จ๊ณ๋ก ๋์๊ฐ๋๋ค.
- ๋ฃจํ๊ฐ ์ข ๋ฃ๋ฉ๋๋ค. ์คํ์ ๊ทธ ๋ค์ ๋ค์ ๋ช ๋ น๋ฌธ์ ์ํด ๊ณ์๋ฉ๋๋ค.
๋ค์์ 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 |
๋๊ธ