๐ฏ 8๊ฐ: ์ค๊ณ ๊ท์น๊ณผ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์ฝ๋ ์์ฑ
์๋ ํ์ธ์ ์ฌ๋ฌ๋ถ! ๐
์ค๋์ ์ฐ๋ฆฌ๊ฐ ๋งค์ผ ์ฐ๋ ํจ์(Function)๋ฅผ ์ด๋ป๊ฒ ์ค๊ณํด์ผ
MISRA-C์ ๋ง๋ ์์ ํ๊ณ ๊น๋ํ ์ฝ๋๋ฅผ ๋ง๋ค ์ ์๋์ง ์ดํด๋ณผ๊ฒ์. ๐
1. ํจ์ ์ธ์์ ๊ฐ์ ์ ํ โ
ํจ์์ ์ธ์๊ฐ ๋๋ฌด ๋ง์ผ๋ฉด ์ฝ๊ธฐ๋ ์ด๋ ต๊ณ , ์ฌ์ฉํ๊ธฐ๋ ํ๋ค์ฃ .
MISRA-C๋ ํจ์ ์ธ์์ ๊ฐ์๋ฅผ 8๊ฐ ์ดํ๋ก ์ ํํ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค.
// ๐จ ๋์ ์์
void process(int a, int b, int c, int d, int e, int f, int g, int h, int i);
// โ
์ข์ ์์ (๊ตฌ์กฐ์ฒด๋ก ๋ฌถ๊ธฐ)
typedef struct {
int a, b, c, d;
} Params;
void process(Params p);
๐ ์ธ์๊ฐ ๋ง์์ง๋ฉด ๊ตฌ์กฐ์ฒด๋ก ๋ฌถ๊ฑฐ๋, ๊ธฐ๋ฅ์ ๋๋์ด ์ค๊ณํ์ธ์!
2. ์ฌ๊ท ํธ์ถ ๊ธ์ง ๐
์ฌ๊ท(Recursion)๋ ๊น๋ํด ๋ณด์ด์ง๋ง, ์คํ ์ค๋ฒํ๋ก์ฐ์ ์ํ์ด ์์ต๋๋ค.
ํนํ ์๋ฒ ๋๋ ํ๊ฒฝ์์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ํ์ ์ด๊ธฐ ๋๋ฌธ์ ์ฌ๊ท๋ ๊ธ์ง๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์.
// ๐จ ๋์ ์์
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
// โ
์ข์ ์์ (๋ฐ๋ณต๋ฌธ ์ฌ์ฉ)
int factorial_iter(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
3. Side Effect ์๋ ํจ์ ์ค๊ณ ๐งผ
Side Effect(๋ถ์ ํจ๊ณผ)๋ ํจ์๊ฐ ์์ ์ ์
๋ ฅ๊ฐ ์ธ์ ์ธ๋ถ ์ํ๋ฅผ ๋ฐ๊ฟ๋ฒ๋ฆฌ๋ ๊ฒ์ ๋งํด์.
์๋ฅผ ๋ค์ด, ์ ์ญ ๋ณ์๋ฅผ ์์ ํ๊ฑฐ๋ I/O๋ฅผ ์ง์ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ๊ฐ ํด๋น๋ฉ๋๋ค.
MISRA-C์์๋ ํจ์๊ฐ ์ ๋ ฅ → ์ถ๋ ฅ์ ๊ด๊ณ๊ฐ ๋ช ํํ ๋๋ฌ๋๋๋ก ์ค๊ณํ๋ ๊ฑธ ๊ถ์ฅํฉ๋๋ค.
// ๐จ ๋์ ์์: ํจ์ ๋ด๋ถ์์ ์ ์ญ ๋ณ์ ์์
int g_counter = 0;
void increment() {
g_counter++; // ์ธ๋ถ ์ํ ๋ณ๊ฒฝ (Side Effect)
}
// โ
์ข์ ์์: ์
๋ ฅ/์ถ๋ ฅ ๊ด๊ณ๊ฐ ๋ช
ํ
int increment(int value) {
return value + 1;
}
๐ ์ด๋ ๊ฒ ํ๋ฉด ํจ์๋ ์์ธก ๊ฐ๋ฅํ๊ณ , ํ ์คํธํ๊ธฐ๋ ์ฌ์์ง๋๋ค!
๐ฏ ์ค๋์ ํต์ฌ ์ ๋ฆฌ
ํจ์ ์ธ์๋ 8๊ฐ ์ดํ๋ก → ๊ฐ๋ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ UP
์ฌ๊ท ํธ์ถ์ ๊ธ์ง → ์์ ํ ๋ฐ๋ณต๋ฌธ ํ์ฉ
Side Effect ์๋ ํจ์ ์ค๊ณ → ์ ๋ขฐ์ฑ๊ณผ ํ ์คํธ ์ฉ์ด์ฑ ๊ฐํ
๐ข ๋ค์ ํ์ฐจ ์๊ณ
๐ MISRA-C์ ์ ์ ๋ถ์ ๋๊ตฌ ํ์ฉ ์ ๋ต ๐ ๏ธ
“๊ท์น์ ์๋์ผ๋ก ๊ฒ์ฌํด์ฃผ๋ ๋๊ตฌ ํ์ฉ๋ฒ”์ ์์๋ด
๋๋ค. ๊ธฐ๋ํด์ฃผ์ธ์! ๐
