ํ๋ก๊ทธ๋จ์์ ์ผ๋ฐ์ ์ธ ์์ธ ์ฒ๋ฆฌ(Exception Handling)ํ๋ ๋ฐฉ๋ฒ
์์ธ ์ฒ๋ฆฌ๊ฐ ์ ํ์ํ ๊น์?
ํ๋ก๊ทธ๋จ์ ์์ธ ์ฒ๋ฆฌ๋ ์์ฃผ ์ค์ํฉ๋๋ค. ๋ด๊ฐ ๋ง๋ ํ๋ก๊ทธ๋จ์ด ๋ชจ๋ ์ํฉ์์ ํญ์ ์ ๋์ํ ๊ฒ์ด๋ผ๋ ๋ณด์ฅ์ ํ ์ ์๊ธฐ ๋๋ฌธ์ด์ฃ . ์๋ฌด๋ฆฌ ์ ๋ง๋ค์๋ค๊ณ ํด๋, ๋ง์ ์ฌ์ฉ์๊ฐ ์ฌ์ฉํ๋ ํ๊ฒฝ์ด๋ ์กฐ์ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ๋ฌด์จ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ง๋ ์ ์๊ฐ ์์ต๋๋ค.
๊ทธ๋์ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ์์ (๊ธฐ์ด ์ธ์ด ๋ฌธ๋ฒ์ ๋ค๋ฃจ๋ ์ฑ ๋ฟ๋ง ์๋๋ผ, ํ๋ก๊ทธ๋จ ์ค๊ณ, ํ๋ก๊ทธ๋๋ฐ ๊ธฐ๋ฒ ๋ฑ)์ ๋ณด๋ฉด, ๊ฑฐ์ ๋๋ถ๋ถ ์์ธ ์ฒ๋ฆฌ์ ์ค์์ฑ์ ๊ฐ์กฐํ๊ณ ์์ต๋๋ค. ์์ธ ์ฒ๋ฆฌ๊ฐ ์ ๋์ด ์์ด์ผ ์์ ์ ์ธ ํ๋ก๊ทธ๋จ์ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ด์ฃ .
์ฐธ๊ณ ๋ก, ์ ๊ฐ ์ธ๊ธํ๋ ์์ธ ์ฒ๋ฆฌ๋ ๋์ค์ ์๊ฐํ ์๋ฌ ์ฒ๋ฆฌ(Error Handling)
์ ์์ธ ์ฒ๋ฆฌ(Exception Handling)
๋ชจ๋๋ฅผ ํต์นญํ๋ ํํ์
๋๋ค.
์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ
์์ธ(๋๋ ์ค๋ฅ)๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์ผ๋ฐ์ ์ผ๋ก ๋ค์์ ์ธ ๊ฐ์ง๊ฐ ์์ต๋๋ค. ์์ผ๋ก ์ธ๊ธํ ์ธ ๊ฐ์ง ์ธ์๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ ์๋ ์๊ณ , ์ด๋ค ๋ฐฉ๋ฒ์ด ์ณ๊ณ ๊ทธ๋ฅด๋ค๊ธฐ๋ณด๋ค๋ ์์ฃผ ๋ณดํธ์ ์ด๋ค๋ผ๋ ์๋ฏธ๋ก ์๊ฐํฉ๋๋ค.
1. ์ค๋ฅ ๋ฌด์ํ๊ธฐ
๋ค์ ํฉ๋นํ ์๋ ์๋ ๋ฐฉ๋ฒ์ด์ง๋ง, ์์ฐ์ค์ ๊ทธ๋ ๊ฒ ์ฌ์ฉํ๊ณ ์์ ์๋ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ ๋ค์ ํจ์๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
int printf_s(
const char *format [,
argument]...
);
์ด ํจ์๋ ์ถ๋ ฅ๋ ๋ฌธ์ ์ ๋๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด ์์๋ฅผ ๋ฐํํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ, ํด๋น ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด์ ๋งค๋ฒ ๋ฐํ ๊ฐ์ด ์์์ธ์ง, ์ถ๋ ฅ๋ ๋ฌธ์ ์์ ๊ฐ์์ง ํ์ธํ ๊น์? ์ฌ์ค ์ด ํจ์๊ฐ ์์๋ฅผ ๋ฐํํ ๊ฐ๋ฅ์ฑ์ ์์ฃผ ์๋นํ ๋ฎ์ต๋๋ค. ์ฌ๋งํ๋ฉด ๊ฑฐ์ ์ ์์ ์ผ๋ก ๋์ํ ๊ฒ๋๋ค.
์ด์ฒ๋ผ, ์ฌ์ํ๋ค๊ณ ์๊ฐํ๋ ๊ฒ๋ค์ ๊ทธ๋ฅ '๋ฌด์'ํ๋ ๊ฒ๋ ๋ฐฉ๋ฒ์ด๊ธด ํฉ๋๋ค๋ง, ํ๋จํ๋ ๊ธฐ์ค์ด ๋ชจํธํ๊ณ ๊ฒฌ๊ณ ํ ํ๋ก๊ทธ๋จ ๋ง๋๋ ๋ฐฉ๋ฒ๊ณผ๋ ๋ค์ ๊ฑฐ๋ฆฌ๊ฐ์ด ์์ต๋๋ค.
2. ์๋ฌ ์ฝ๋(Error Code) ๋ฐํํ๊ธฐ - Error Handling
ํน์ ํจ์๋ฅผ ํธ์ถํ๋ฉด ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ์ ์๋ก ๋ฐํํ๋ ๋ฐฉ์์ ๋ง์ด ์ ํด๋ดค์ ํ
๋ฐ์. ์๋ฌ ์ฝ๋ ๋ฐํํ๊ธฐ๊ฐ ๋ฐ๋ก ๊ทธ๋ฐ ๋ฐฉ๋ฒ์
๋๋ค. ํจ์ ํธ์ถ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ boolean
์ผ๋ก ๋ฐํํ ์๋ ์๊ณ , int
๋ ์๋ฌ๋ฅผ ์ ์ํ struct
๋ก ๋ฐํํ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
ํ์ง๋ง, ์ด๋ฌํ ์ฝ๋๋ ์ง์ ๋ถํ ์ฝ๋๋ฅผ ์ผ๊ธฐํฉ๋๋ค. ๋๋ถ๋ถ์ ์์ ์์๋ ์ธ๊ธํ๋ ๋ด์ฉ์ธ๋ฐ์. ํญ์ ํจ์๋ฅผ ํธ์ถํ๊ณ if-else ๋ฌธ
์ผ๋ก ์๋ฌ๋ฅผ ํ์ธํ๊ธฐ ๋๋ฌธ์ด์ฃ .
int result = doSomething();
if (result == 0)
{
//๋์ ์ฑ๊ณต
}
else if (result == -1)
{
//์๋ฌ1
}
else if (result == -2)
{
//์๋ฌ2
}
//...
๋ฌผ๋ก , ๋ณดํต์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ๊ธฐ๋ ํฉ๋๋ค.
int result = doSomething();
if (result != 0)
{
//์ค๋ฅ ๋ณด๊ณ
}
//...
์ด ๋ฐฉ๋ฒ๋ก ์ ํต์ฌ์, ๋งค๋ฒ ์ค๋ฅ ์ฝ๋๋ฅผ ํ์ธํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์๊ณผ ๋ฐํ ์ฝ๋์ ๋ฐ๋ผ if-else๋ฌธ์ด ๋ง์์ง๋ฉด ์ ์ง๋ณด์์ ๊น๋ค๋ก์์ด ์๋ค๋ ๊ฒ์ด์ฃ .
3. ์์ธ(Exception) ์ฌ์ฉํ๊ธฐ - Exception Handling
์ด๋ ์์ ์ด๋ ์์ธ๋ฅผ ์๊ฐํ๋ ํํธ๊ฐ ์๋ค๋ฉด, ๋ค๋ค ์์ธ๋ฅผ ์ฌ์ฉํ๋ผ๊ณ ๊ถ์ฅํฉ๋๋ค(๋ฌผ๋ก , ํญ์ ์ข์ ์ ๋ง ์๋ ๊ฒ์ ์๋์ฃ ). ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๊ณ , ์์ธ๊ฐ ๋ฐ์ํ์ ๋ ์ค๋ฅ๋ฅผ ๋ณด๊ณ ํ๊ณ ์กฐ์นํ๊ธฐ๊ฐ ๊ฐํธํ๋ฉฐ ์์ธ๋ฅผ ๋ฐ์์ํจ ์์ธ์ ๋ฐ๋ผ ๋ค๋ฅธ ์์ ์ ์ํํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
์์ธ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ C++ ๋ฌธ๋ฒ์ ์์ฃผ ๊ฐ๋จํฉ๋๋ค(๋ณธ๋ฌธ์์๋ ๋ฌธ๋ฒ์ ๋ํด ์์ธํ ์ค๋ช ํ์ง ์์ต๋๋ค).
//C++
void doSomething()
{
//...
thorw std::exception("์์ธ ๋ฉ์์ง");
}
int main()
{
try
{
doSomething();
}
catch(const std::exception &e)
{
//e.what();
}
}
ํน์ ํจ์์์ ์์
์ ์ํํ๋ค๊ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉด ์์ธ๋ฅผ ๋์ง(throw)
๋๋ค. ๋์ ธ์ง ์์ธ๋ ๊ฐ์ฅ ๊ฐ๊น์ด try-catch ๋ธ๋ก
๊น์ง ์๋์ผ๋ก ์ ํ๋๊ณ , catch
๋ ์์ธ์์ ์ค๋ฅ ๋ฉ์์ง๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
ํนํ C#์์๋ Exception ๊ฐ์ฒด์ StackTrace
๋ฅผ ํตํด ์ด๋์ ์์ธ๊ฐ ๋์ ธ์ก๋์ง ํ์ธํ ์ ์์ต๋๋ค.
static void doSomething()
{
throw new Exception("์์ธ ๋ฐ์!");
}
static void Main(string[] args)
{
try
{
doSomething();
}
catch(Exception exc)
{
Console.WriteLine(exc.StackTrace);
Console.WriteLine(exc.Message);
}
}
์ ์ฝ๋๋ฅผ ์คํํ๋ฉด StackTrace๋ฅผ ํตํด ์์ธ ๋ฉ์์ง์ ์์ธ๊ฐ ๋์ ธ์ง ์์ค ์ฝ๋์ ์์น๋ฅผ ์ ์ ์์ต๋๋ค.
์ฐธ๊ณ
- C++ For Game Programmers - Second Edition, Michale J. Dickheiser
'Programming' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋๊ธ
์ด ๊ธ ๊ณต์ ํ๊ธฐ
-
๊ตฌ๋
ํ๊ธฐ
๊ตฌ๋ ํ๊ธฐ
-
์นด์นด์คํก
์นด์นด์คํก
-
๋ผ์ธ
๋ผ์ธ
-
ํธ์ํฐ
ํธ์ํฐ
-
Facebook
Facebook
-
์นด์นด์ค์คํ ๋ฆฌ
์นด์นด์ค์คํ ๋ฆฌ
-
๋ฐด๋
๋ฐด๋
-
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
-
Pocket
Pocket
-
Evernote
Evernote
๋ค๋ฅธ ๊ธ
-
[C++] C++์์ ๊ตฌ์กฐ์ ์์ธ ์ฒ๋ฆฌ(SEH) ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
[C++] C++์์ ๊ตฌ์กฐ์ ์์ธ ์ฒ๋ฆฌ(SEH) ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
2022.10.18 -
์์ธ ์คํ ํ๊ธฐ(Stack Unwinding)์ ํ๋ก๊ทธ๋จ ์ฑ๋ฅ ์ํฅ
์์ธ ์คํ ํ๊ธฐ(Stack Unwinding)์ ํ๋ก๊ทธ๋จ ์ฑ๋ฅ ์ํฅ
2022.10.12 -
๊ตฌ์กฐ์ ์์ธ ์ฒ๋ฆฌ(SEH, Structured Exception Handling) ๊ธฐ์ด ์ด์ผ๊ธฐ
๊ตฌ์กฐ์ ์์ธ ์ฒ๋ฆฌ(SEH, Structured Exception Handling) ๊ธฐ์ด ์ด์ผ๊ธฐ
2022.08.28