์์ธ๋ ์ฒ๋ฆฌ๊ธฐ ๋ผ๋ ํน์ ํจ์์ ์ ์ด๋ฅผ ์ ๋ฌํ์ฌ ํ๋ก๊ทธ๋จ์ ์์ธ์ ์ธ ์ํฉ(์: ๋ฐํ์ ์ค๋ฅ)์ ๋์ํ๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํฉ๋๋ค .
์์ธ๋ฅผ ํฌ์ฐฉํ๊ธฐ ์ํด ์ฝ๋์ ์ผ๋ถ๊ฐ ์์ธ ๊ฒ์ฌ๋ฅผ ๋ฐ์ต๋๋ค. ์ด๋ ์ฝ๋์ ํด๋น ๋ถ๋ถ์ try-block ์ผ๋ก ๋ฌถ์์ผ๋ก์จ ์ํ๋ฉ๋๋ค . ํด๋น ๋ธ๋ก ๋ด์์ ์์ธ์ ์ธ ์ํฉ์ด ๋ฐ์ํ๋ฉด ์์ธ ์ฒ๋ฆฌ๊ธฐ๋ก ์ ์ด๋ฅผ ์ ์กํ๋ ์์ธ๊ฐ ๋ฐ์ํฉ๋๋ค. ์์ธ๊ฐ ๋ฐ์ํ์ง ์์ผ๋ฉด ์ฝ๋๊ฐ ์ ์์ ์ผ๋ก ๊ณ์๋๊ณ ๋ชจ๋ ์ฒ๋ฆฌ๊ธฐ๊ฐ ๋ฌด์๋ฉ๋๋ค. ๋ธ๋ก ๋ด๋ถ์์ ํค์๋๋ฅผ
์ฌ์ฉํ๋ฉด ์์ธ๊ฐ ๋ฐ์ํฉ๋๋ค . ์์ธ ์ฒ๋ฆฌ๊ธฐ๋ ๋ธ๋ก ๋ฐ๋ก ๋ค์ ๋ฐฐ์นํด์ผ ํ๋ ํค์๋๋ก ์ ์ธ๋ฉ๋๋ค .throwtrycatchtry
// exceptions
#include <iostream>
using namespace std;
int main () {
try
{
throw 20;
}
catch (int e)
{
cout << "An exception occurred. Exception Nr. " << e << '\n';
}
return 0;
}
์์ธ ์ฒ๋ฆฌ ์ค์ธ ์ฝ๋๋ try๋ธ๋ก์ผ๋ก ๋ฌถ์ ๋๋ค. ์ด ์์์ ์ด ์ฝ๋๋ ๋จ์ํ ์์ธ๋ฅผ ๋ฐ์์ํต๋๋ค.
throw 20;
ํํ์์ ์์ธ ํธ๋ค๋ฌ์ ์ธ์๋ก ์ ๋ฌ๋๋ ํ๋์ ๋งค๊ฐ๋ณ์(์ด ๊ฒฝ์ฐ ์ ์ ๊ฐ)๋ฅผ ํ์ฉ throwํฉ๋๋ค . ์์ธ ์ฒ๋ฆฌ๊ธฐ๋ ๋ธ๋ก ์ ๋ซ๋ ์ค๊ดํธ ๋ฐ๋ก ๋ค์ ํค์๋ ๋ก ์ ์ธ๋ฉ๋๋ค . ์ ๋ํ ๊ตฌ๋ฌธ ์ ๋งค๊ฐ๋ณ์๊ฐ ํ๋์ธ ์ผ๋ฐ ํจ์์ ์ ์ฌํฉ๋๋ค. ์ด ๋งค๊ฐ๋ณ์์ ์ ํ์ ํํ์์ ์ํด ์ ๋ฌ๋ ์ธ์์ ์ ํ์ด ์ด์ ๋ํด ๊ฒ์ฌ๋๊ณ ์ผ์นํ๋ ๊ฒฝ์ฐ์๋ง ํด๋น ํธ๋ค๋ฌ์์ ์์ธ๋ฅผ ํฌ์ฐฉํ๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ฌ๋ฌ ํธ๋ค๋ฌ(์ฆ, ํํ์)๋ฅผ ์ฐ๊ฒฐํ ์ ์์ต๋๋ค. ๊ฐ๊ฐ ๋ค๋ฅธ ๋งค๊ฐ๋ณ์ ์ ํ์ ์ฌ์ฉํฉ๋๋ค. ์ธ์ ์ ํ์ด ๋ช
๋ น๋ฌธ์ ์ง์ ๋ ์์ธ ์ ํ๊ณผ ์ผ์นํ๋ ํธ๋ค๋ฌ๋ง ์คํ๋ฉ๋๋ค.20
catchtrycatchthrow
catchthrow
์ค์ํ( ...)๊ฐ ์ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉ๋๋ catch๊ฒฝ์ฐ ํด๋น ์ฒ๋ฆฌ๊ธฐ๋ throw๋ ์์ธ ์ ํ์ ๊ด๊ณ์์ด ๋ชจ๋ ์์ธ๋ฅผ catchํฉ๋๋ค. ์ด๊ฒ์ ๋ค๋ฅธ ํธ๋ค๋ฌ๊ฐ ํฌ์ฐฉํ์ง ๋ชปํ ๋ชจ๋ ์์ธ๋ฅผ ํฌ์ฐฉํ๋ ๊ธฐ๋ณธ ํธ๋ค๋ฌ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค.
try {
// code here
}
catch (int param) { cout << "int exception"; }
catch (char param) { cout << "char exception"; }
catch (...) { cout << "default exception"; }
์ด ๊ฒฝ์ฐ ๋ง์ง๋ง ํธ๋ค๋ฌ๋ int๋๋ ๋ ์๋ ์ ํ์์ throw๋ ๋ชจ๋ ์์ธ๋ฅผ catchํฉ๋๋ค char.
ํ๋ก๊ทธ๋จ์์ ์์ธ๊ฐ ์ฒ๋ฆฌ๋ ํ ๋ช
๋ น๋ฌธ ์ด ์๋๋ผ try-catch ๋ธ๋ก ํ์ ์คํ์ด ์ฌ๊ฐ๋ฉ๋๋ค. ๋ ๋ง์ ์ธ๋ถ ๋ธ๋ก ๋ด์ ๋ธ๋ก ์ ์ค์ฒฉํ ์๋ ์์ต๋๋ค . ์ด๋ฌํ ๊ฒฝ์ฐ ๋ด๋ถ ๋ธ๋ก์ด ์์ธ๋ฅผ ์ธ๋ถ ์์ค์ผ๋ก ์ ๋ฌํ ๊ฐ๋ฅ์ฑ์ด ์์ต๋๋ค. ์ด๋ ์ธ์๊ฐ ์๋ ํํ์์ผ๋ก ์ํ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด:throw
try-catchtrycatchthrow;
try {
try {
// code here
}
catch (int n) {
throw;
}
}
catch (...) {
cout << "Exception occurred";
}
์์ธ ์ฌ์
์ด์ ์ฝ๋์๋ ๋์ ์์ธ ์ฌ์ ์ด ํฌํจ๋ ์ ์์ต๋๋ค . ์ด์ C++์์ ๋ ์ด์ ์ฌ์ฉ๋์ง ์์ง๋ง ์ฌ์ ํ ์ง์๋ฉ๋๋ค. ๋์ ์์ธ ์ฌ์ ์ ํจ์ ์ ์ธ ๋ค์์ ์ง์ ์๋ฅผ ์ถ๊ฐ ํฉ๋๋ค throw. ์๋ฅผ ๋ค์ด:
double myfunction (char param) throw (int);
myfunction์ด๊ฒ์ type ์ ํ๋์ ์ธ์๋ฅผ ์ทจํ๊ณ type char์ ๊ฐ์ ๋ฐํํ๋ ์ด๋ผ๋ ํจ์๋ฅผ ์ ์ธํฉ๋๋ค double. ์ด ํจ์๊ฐ ๊ฐ ์๋ ๋ค๋ฅธ ์ ํ์ ์์ธ๋ฅผ throwํ๋ ๊ฒฝ์ฐ ํจ์๋ ๋ค์์ intํธ์ถํฉ๋๋ค.std::์์์น ๋ชปํํธ๋ค๋ฌ๋ฅผ ์ฐพ๊ฑฐ๋ ํธ์ถํ๋ ๋์ ํ์ค::์ข
๋ฃ.
์ด throw์ง์ ์๊ฐ ์ ํ ์์ด ๋น์ด ์์ผ๋ฉด ์ด๋ ๋ค์์ ์๋ฏธํฉ๋๋ค.std::์์์น ๋ชปํ๋ชจ๋ ์์ธ์ ๋ํด ํธ์ถ๋ฉ๋๋ค. ์ง์ ์๊ฐ ์๋ throwํจ์(์ผ๋ฐ ํจ์)๋ ํธ์ถํ์ง ์์ต๋๋ค .std::์์์น ๋ชปํ๊ทธ๋ฌ๋ ์์ธ ์ฒ๋ฆฌ๊ธฐ๋ฅผ ์ฐพ๋ ์ผ๋ฐ์ ์ธ ๊ฒฝ๋ก๋ฅผ ๋ฐ๋ฅด์ญ์์ค.
int myfunction (int param) throw(); // all exceptions call unexpected
int myfunction (int param); // normal exception handling
ํ์ค ์์ธ
C++ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์์ธ๋ก throw๋ ๊ฐ์ฒด๋ฅผ ์ ์ธํ๋๋ก ํน๋ณํ ์ค๊ณ๋ ๊ธฐ๋ณธ ํด๋์ค๋ฅผ ์ ๊ณตํฉ๋๋ค. ํค๋ std::exception์ ์ ์๋์ด ํธ์ถ ๋ฉ๋๋ค. ์ด ํด๋์ค์๋ null๋ก ๋๋๋ ๋ฌธ์ ์ํ์ค(ํ์ )๋ฅผ ๋ฐํํ๊ณ ํ์ ํด๋์ค์์ ๋ฎ์ด์จ์ ์์ธ์ ๋ํ ์ผ์ข ์ ์ค๋ช ์ ํฌํจํ ์ <exception>์๋ ๊ฐ์ ๋ฉค๋ฒ ํจ์ ๊ฐ ์์ต๋๋ค.whatchar *
// using standard exceptions
#include <iostream>
#include <exception>
using namespace std;
class myexception: public exception
{
virtual const char* what() const throw()
{
return "My exception happened";
}
} myex;
int main () {
try
{
throw myex;
}
catch (exception& e)
{
cout << e.what() << '\n';
}
return 0;
}
์์ธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ๋ก ์ก๋ ํธ๋ค๋ฌ๋ฅผ ๋ฐฐ์นํ์ต๋๋ค(์ ํ ๋ค์ ์ฐํผ์๋์ ์ฃผ์ ). ๋ฐ๋ผ์ ์ด๊ฒ์ type ์ ๊ฐ์ฒด ์ ๊ฐ์ด &์์ ํ์๋ ํด๋์ค๋ ์บ์น ํฉ๋๋ค . C++ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊ตฌ์ฑ ์์์์ throw๋ ๋ชจ๋ ์์ธ๋ ์ด ํด๋์ค์์ ํ์๋ ์์ธ๋ฅผ throwํฉ๋๋ค. ์ด๊ฒ๋ค์:exceptionmyexmyexception
exception
์์ธ | ์ค๋ช |
bad_alloc | newํ ๋น ์คํจ ์ ๋ฐ์ |
bad_cast | dynamic_cast๋์ ์บ์คํธ์์ ์คํจํ ๋ ๋ฐ์ |
bad_exception | ํน์ ๋์ ์์ธ ์ง์ ์์ ์ํด ๋ฐ์ |
bad_typeid | ์ ์ํด ๋์ ธtypeid |
bad_function_call | function๋น ๊ฐ์ฒด ์ ์ํด ๋์ง |
bad_weak_ptr | shared_ptr๋์ ํต๊ณผํ์ ๋ ๋์งweak_ptr |
exception๋ํ , ํค๋ ์์ ํ์๋ ํค๋ <exception>๋ ์ค๋ฅ๋ฅผ ๋ณด๊ณ ํ๊ธฐ ์ํด ์ฌ์ฉ์ ์ ์ ์์ธ์ ์ํด ์์๋ ์ ์๋ ๋ ๊ฐ์ง ์ผ๋ฐ ์์ธ ์ ํ์ ์ ์ํฉ๋๋ค.
์์ธ | ์ค๋ช |
logic_error | ํ๋ก๊ทธ๋จ์ ๋ด๋ถ ๋ ผ๋ฆฌ์ ๊ด๋ จ๋ ์ค๋ฅ |
runtime_error | ๋ฐํ์ ์ค์ ์ค๋ฅ๊ฐ ๊ฐ์ง๋์์ต๋๋ค. |
ํ์ค ์์ธ๋ฅผ ํ์ธํด์ผ ํ๋ ์ผ๋ฐ์ ์ธ ์๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ๋ํ ๊ฒ์
๋๋ค.
// bad_alloc standard exception
#include <iostream>
#include <exception>
using namespace std;
int main () {
try
{
int* myarray= new int[1000];
}
catch (exception& e)
{
cout << "Standard exception: " << e.what() << endl;
}
return 0;
}
์ด ์์์ ์์ธ ์ฒ๋ฆฌ๊ธฐ์ ์ํด catch๋ ์ ์๋ ์์ธ๋ bad_alloc. bad_alloc์(๋) ํ์ค ๊ธฐ๋ณธ ํด๋์ค์์ ํ์ ๋์๊ธฐ ๋๋ฌธ์ exception์ก์ ์ ์์ต๋๋ค(์ฐธ์กฐ๋ก ์บก์ฒ, ๋ชจ๋ ๊ด๋ จ ํด๋์ค ์บก์ฒ).
'๐ Development Study > ๐จ๐พโ๐ป C++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ์ผ ์ ์ถ๋ ฅ (1) | 2022.08.22 |
---|---|
์ ์ฒ๋ฆฌ๊ธฐ #define (1) | 2022.08.22 |
ํ๋ณํ (0) | 2022.08.22 |
๋คํ์ฑ (0) | 2022.08.22 |
์์ / ํ๋ ๋ (0) | 2022.08.22 |
๋๊ธ