๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“ Development Study/๐Ÿ‘จ๐Ÿพ‍๐Ÿ’ป C++

exception

by eazuooz 2022. 8. 22.

์˜ˆ์™ธ๋Š” ์ฒ˜๋ฆฌ๊ธฐ ๋ผ๋Š” ํŠน์ˆ˜ ํ•จ์ˆ˜์— ์ œ์–ด๋ฅผ ์ „๋‹ฌํ•˜์—ฌ ํ”„๋กœ๊ทธ๋žจ์˜ ์˜ˆ์™ธ์ ์ธ ์ƒํ™ฉ(์˜ˆ: ๋Ÿฐํƒ€์ž„ ์˜ค๋ฅ˜)์— ๋Œ€์‘ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค .

์˜ˆ์™ธ๋ฅผ ํฌ์ฐฉํ•˜๊ธฐ ์œ„ํ•ด ์ฝ”๋“œ์˜ ์ผ๋ถ€๊ฐ€ ์˜ˆ์™ธ ๊ฒ€์‚ฌ๋ฅผ ๋ฐ›์Šต๋‹ˆ๋‹ค. ์ด๋Š” ์ฝ”๋“œ์˜ ํ•ด๋‹น ๋ถ€๋ถ„์„ 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

๋Œ“๊ธ€