๋ฌธ์ฅ
๋์ด ์ธ๋ฏธ์ฝ๋ก (;)์ผ๋ก ๋๋จ
; ์๋ฌด๊ฒ๋ ์์ด ์ธ๋ฏธ์ฝ๋ก ๋ง ์์ด๋ ๋ฌธ์ฅ์ด๋ค.
{ } - ๋ณตํฉ๋ฌธ(compound statement)
์ ์ด๋ฌธ(if, for, while, switch ๋ฑ)๋ ๋ฌธ์ฅ์ ํด๋นํ๋ค.
Operators (์ฐ์ฐ์)
Program Flow Operators
- ํ๋ก๊ทธ๋จ์ ์ ์ดํ๋ ์ธ ๊ฐ์ง ์ฐ์ฐ์
(1) ํจ์ ํธ์ถ : C++์์๋ ์ฐ์ฐ์๋ก ์ทจ๊ธ
(2) ์กฐ๊ฑด ์ฐ์ฐ์ : x ? a : b , ์กฐ๊ฑด x๋ฅผ ๋ง์กฑํ๋ฉด(true) ํํ์ ๊ฐ์ a๊ฐ์ ๊ฐ์ง๊ณ ์๋๋ฉด(false) b์ ๊ฐ์ ๊ฐ์ง
(3) ์ฝค๋ง ์ฐ์ฐ์ : E1, E2 ์ฝค๋ง์ ์ผ์ชฝ์ ์๋ E1๋ฅผ ๋จผ์ ๊ณ์ฐํ ๋ค ์ค๋ฅธ์ชฝ์ ์๋ E2๋ฅผ ๊ณ์ฐํ๋ฉฐ ํํ์ ๊ฐ์ E2์ ๊ฐ์
(์ฐ์ฐ์ ์ฐ์ ์์ ์ค ์ฝค๋ง ์ฐ์ฐ์๊ฐ ๊ฐ์ฅ ๋ฎ์)
if ๋ฌธ
- ์กฐ๊ฑด์ ๋ฐ๋ผ์ 2๊ฐ ์ด์์ ์์น๋ก ์ ์ด๋ฅผ ๋ถ๊ธฐ
- ๋ณต์ ๋ฌธ์ฅ์ ์คํ ํ ๊ฒฝ์ฐ ์คํ๋ฌธ์ { } ์ผ๋ก ๋ธ๋ก์ ๋ง๋ ๋ค.
- ์ฌ๋ฌ ๊ฐ์ง์ ์กฐ๊ฑด๋ฌธ์ ์์ฑํ ๊ฒฝ์ฐ์๋ else if๋ฅผ ์ฌ์ฉํ๋ค
- if ๋ฌธ์ ์ค์ฒฉ์์ผ ๋ณต์กํ ์กฐ๊ฑด๋ฌธ์ ํํ์ด ๊ฐ๋ฅํ๋ค.
ex)
(์ฃผ์) ์ค์ ๊ฐ์ ๋ํด์๋ ๋๋ฑ ๋น๊ต(==)๋ฅผ ๊ถ์ฅํ์ง ์๋๋ค ์ค์ ๊ฐ์ ๋น๊ต๋ epsilon(์ก์ค๋ก )์ ์ด์ฉํ๋ค. epsilon(์ก์ค๋ก )์ด๋ ๋ถ๋์์์ ์ ์ค์ฐจ ๋ฒ์๋ฅผ ๋ํ๋ด๋ ๋งค์ฐ ์์ ๊ฐ์ ์๋ฏธํ๋ค.
#include <iostream>
#include <cmath> // for std::abs
#include <limits> // for std::numeric_limits
bool areAlmostEqual(double a, double b) {
return std::abs(a - b) < std::numeric_limits<double>::epsilon(); //์ก์ค๋ก ์ฌ์ฉ
}
int main() {
double x = 0.1 + 0.2;
double y = 0.3;
if (areAlmostEqual(x, y)) {
std::cout << "x and y are almost equal." << std::endl;
} else {
std::cout << "x and y are not equal." << std::endl;
}
return 0;
}
ex)
A && B : and ์กฐ๊ฑด๋ฌธ : A๋ B๊ฐ ํ๋๋ผ๋ false๋ฉด false๊ฐ ๋จ
A || B : or ์กฐ๊ฑด๋ฌธ : A๊ฐ true์ด๋ฉด B๋ ํ๊ฐํ์ง ์์๋ true๊ฐ ๋จ
&&์ ||์ ํ ๋ฌธ์ฅ์์ ์ฌ์ฉํ๋ ๋ฑ, ์ฌ๋ฌ ๊ฐ์ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด () ๊ดํธ๋ฅผ ์ฌ์ฉํ๋ค.
&&! : and not ๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
์กฐ๊ฑด๋ฌธ๊ณผ ์กฐ๊ฑด ์ฐ์ฐ์
์กฐ๊ฑด๋ฌธ์ ์กฐ๊ฑด ์ฐ์ฐ์ (ํ๋ก๊ทธ๋จ์ ๊ฐ๋ ์ฑ์ ๋์ด๊ณ ์ถ์ ๊ฒฝ์ฐ ์ฌ์ฉ) ๋ก ๊ฐ๋จํ๊ฒ ํํ ๊ฐ๋ฅํ๋ค.
Switch ๋ฌธ
- ๋์ผํ ๊ธฐ์ค์ ๋ฐ๋ฅธ ๋ณต์๊ฐ์ ๋ถ๊ธฐ ์ํฉ์ ํํ
- ๊ฐ case๋ฅผ ๋ธ๋ก์ผ๋ก ์ ์ํ์ฌ ์ง์ญ ๋ณ์๋ฅผ ์ ์
- case๋ฅผ ๋ณต์ ๊ฐ ๋์ดํ์ฌ ๋์ผํ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ค
- ๋ง์ง๋ง์ ๋ฐ๋์ default๊ฐ ์ ์๋์ด์ผ ํ๋ค.
- switch ๋ฌธ์ ๋์ดํ์ ๋ณ์(enum)์ ํจ๊ป ์ฌ์ฉํ ์ ์๋ค.
- ์ค์ ๊ฐ ๋๋ ๋ฒ์๊ฐ์ ๋ฐ๋ฅธ ๋ถ๊ธฐ๋ ํํํ ์ ์๋ค.
ex)
- ์๋๋ ๋ชจ๋ ๋ถ๊ฐ๋ฅํ ์์์ด๋ค.
for ๋ฌธ
- ์ผ์ ํ์์ ๋์์ ๋ฐ๋ณต์ ์ผ๋ก ์ํํ ๋ ์ ์ฉํ๋ค.
- for๋ฌธ์ผ๋ก ๋ฐฐ์ด(array)์ ์ ๊ทผํ ๋๋ ์ธ๋ฑ์ค ๋ณ์๋ 0๋ถํฐ ์์ํ๊ณ , ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ์์ ์กฐ๊ฑด์ ์ฌ์ฉํด์ผ ํ๋ค.
- vector ๋ฑ๊ณผ ๊ฐ์ ์ปฌ๋ ์ ์ ๊ฐ ์์๋ฅผ for๋ฌธ(iterator=์ดํฐ๋ ์ดํฐ=๋ฐ๋ณต๋ฌธ=ํฌ์ธํฐ์ ๋น์ท)์ ํตํด ์ ๊ทผํ ์ ์๋ค.
- for๋ฌธ์์ ์ฝค๋ง์์ ์ฌ์ฉ์ ์์ ํ๋ ๊ฒ์ด ์ข๋ค (๊ฐ๋ ์ฑ, ๊ฐ๊ฒฐํจ์ ์ํด)
While ๋ฌธ
- ์ผ๋ฐ์ ์ธ ํํ๋ก ๋ฐ๋ณต์ ํํ
- ์กฐ๊ฑด์์ด ์ฐธ์ธ ๋์ ๋ฐ๋ณต
do - While ๋ฌธ
- ์กฐ๊ฑด์ด ์ฐธ์ธ ๋์ ๋ฐ๋ณต
- ์ต์ 1ํ ์ด์์ ์ํ(do)
continue
- ๋ฐ๋ณต๋ฌธ์์ ์กฐ๊ฑด์ ๋ถํฉ๋์ง ์์ ๋๋ ์ดํ ๋ฌธ์ฅ์ ์ํํ์ง ์์
break
- ๋ฐ๋ณต๋ฌธ์์ ๋ฐ๋ณต๋ฌธ์ ๋ฒ์ด๋ ๋ ์ฐ์ธ๋ค ex) switch๋ฌธ์์ switch๋ฌธ์ ๋ฒ์ด๋ ๋
return
- ํจ์์ ์ํ์ ์ข ๋ฃ
- return๋ฌธ์ ํจ์์ ๋ง์ง๋ง ๋ฌธ์ฅ์ผ๋ก 1ํ๋ง ์ฌ์ฉํ๋ค