[C++] Exceptions | 예외
Exceptions
예외
- 예측하지 못한, 프로그램을 정상적으로 실행할 수 없는 상황에 대한 대처방법을 기술하는 기능이다.
- 구형 컴파일러에서는 지원되지 않을 수 있다.
- 일부 컴파일러에서는 Exceptions 기능을 Disable해 놓는 것이 Default Options이다.
\(\texttt{std::abort()}\) 함수
- \(\texttt{cstdlib}\) 또는 \(\texttt{stdlib.h}\) 헤더파일에 정의되어 있는 함수이다.
- \(\texttt{cerr}\)가 사용하는 스트림(표준 에러 스트림)에 "abnormal program termination" 메시지를
출력하고, 프로그램을 종료시킨다.
(\(\texttt{abort()}\)를 호출한 함수를 종료하는 것이 아닌, 프로그램 자체를 종료시킨다.)
- \(\texttt{abort()}\) 함수를 호출한 프로그램이 다른 프로그램에 의해 구동되는 Child Process(자식 프로세스)인 경우,
Parent Process(부모 프로세스) 혹은 OS(운영체제)에게 컴파일러에 종속적인 특정값을 리턴하게 된다.
- \(\texttt{abort()}\) 함수가 File Buffer*를 비우는지에 대한 여부는 시스템마다 상이하다.
- \(\texttt{exit()}\) 함수를 명시적으로 사용하여 메시지를 출력하지 않고, File Buffer만 비울 수 있다.
* File Buffer
- 파일에 전송할 내용, 파일로부터 전송받을 내용을 저장하는 데 사용되는 메모리 영역을 의미한다.
// Harmonic Mean (조화 평균) 계산 프로그램
// abort() 함수를 이용하여 예외상황을 비정상 종료시키는 코드
#include <iostream>
#include <cstdlib>
double hmean(double a, double b);
int main() {
double x, y, z;
std::cout << "Enter two numbers: ";
while (std::cin >> x >> y) {
z = hmean(x,y);
std::cout << "Harmonic mean of " << x << " and " << y << " is " << z << std::endl;
std::cout << "Enter next set of numbers <q to quit>: ";
}
std::cout << "Bye!\n";
return 0;
}
double hmean(double a, double b) {
if (a == -b) {
std::cout << "untenable arguments to hmean()\n";
std::abort();
}
return 2.0 * a * b / (a + b);
}Returning an Error Code (에러 코드 리턴)
- 함수의 리턴값을 이용하여 문제의 종류를 구분지을 수 있게하는 방법이다.
- 예외를 무조건 비정상 종료시키는 방법보다, 예외 상황에 더 유연하게 대처하는 형태이다.
ex) ostream 클래스의 get(void) 메서드는 파일 내용의 끝(예외 상황)을 감지하면 EOF를 리턴한다.
// Harmonic Mean (조화 평균) 계산 프로그램
// 에러 코드를 리턴함으로써 예외상황에 대처하는 코드
#include <iostream>
#include <cfloat> // (or float.h) for DBL_MAX
bool hmean(double a, double b, double * ans);
int main() {
double x, y, z;
std::cout << "Enter two numbers: ";
while (std::cin >> x >> y) {
if (hmean(x,y,&z))
std::cout << "Harmonic mean of " << x << " and " << y << " is " << z << std::endl;
else
std::cout << "One value should not be the negative " << "of the other - try again.\n";
std::cout << "Enter next set of numbers <q to quit>: ";
}
std::cout << "Bye!\n";
return 0;
}
bool hmean(double a, double b, double * ans) {
if (a == -b) {
*ans = DBL_MAX;
return false;
}
else {
*ans = 2.0 * a * b / (a + b);
return true;
}
}
※ 리턴 조건을 위 프로그램처럼 포인터/참조형 매개변수로 넘기는 대신,
전역변수로 선언하여 호출하는 함수가 항시 확인할 수 있도록 하는 기법도 있다.
(전통적인 C math Library에서 사용되는 방법이다.)
C++ Exception Mechanism (C++ 예외 메커니즘)
- C++에서 제공하는 예외 처리 메커니즘은 예외가 발생한 부분에서
미리 지정해 놓은 지점(Exception Handler)으로 제어를 넘기는 방식으로 진행된다.
- 예외가 발생하면, 발생한 부분의 함수를 종료하고, try Block이 기술되어 있는 함수를 발견할 때 까지
함수들을 거슬러 올라간다.
※ C++ 예외 처리 메커니즘의 절차
1. Throwing an exception (예외 발생)
2. Catching an exception with a handler (핸들러를 이용한 예외 포착)
3. Using a \(\texttt{try}\) block (\(\texttt{try}\) 블록 사용)
Keyword: \(\texttt{throw}\)
- 예외 발생 시, 출력할 내용을 기술한다.
- \(\texttt{throw}\) 키워드의 뒤에는 예외 상황을 기술한 문자열 혹은 객체와 같은 하나의 값을 기술한다.
- \(\texttt{throw}\)문은 기본적으로 객체의 복사본을 \(\texttt{catch}\) Block에 전달한다.
(\(\texttt{catch}\) Block과 \(\texttt{throw}\)가 넘기는 객체의 Scope가 겹치지 않는 경우가 더 많기 때문이다.)
throw "Unexpected error.";※ 또한, \(\texttt{throw}\) 뒤에 아무런 객체도 위치시키지 않음으로써,
그 위치(Callee)에서 Caller로 제어를 넘기는데 이용하기도 한다.
- 기본적으로, \(\texttt{throw}\)문이 실행되면 Unwinding Stack(스택 풀기)가 수행되면서,
Callee에서 Caller의 \(\texttt{catch}\) Block으로 제어가 옮겨진다.
(\(\texttt{catch}\) Block에서 사용하여 예외를 재발생시켜, 해당 함수를 한 층 더 벗어나게 한다.)
throw;
Keyword: \(\texttt{catch}\)
- Exception Handler(포착한 예외에 대한 처리방법)을 기술한다.
(Exception Handler = \(\texttt{catch}\) Block)
- \(\texttt{throw}\) 키워드로부터 넘겨받은 객체의 데이터 타입을 소괄호 안에 명시해야 한다.
(\(\texttt{throw}\)가 넘긴 객체의 데이터 타입과 \(\texttt{catch}\)에서 명시한 데이터 타입이 일치해야 해당 Exception Handler가 동작한다.)
- \(\texttt{catch}\) 키워드는 예외 발생 시, 프로그램 제어를 넘겨받기 위한 레이블의 역할을 한다.
(즉, \(\texttt{catch}\) Block은 함수가 아니다.)
catch (const char* s) {
cout << s << std::endl;
...
}※ \(\texttt{catch}\) Block에서는 \(\texttt{throw}\)로 부터 객체의 복사본을 넘겨받는다.
- \(\texttt{catch}\) Block의 데이터형을 참조로 선언한다 해도, 복사본을 넘겨받게 된다.
- 객체가 해당 Scope를 넘어가서 전달되기 전에 소멸되는 것을 방지하기 위함이다.
- 그럼에도 불구하고, 참조 선언을 가능하게 한 이유는 상속 관계에 있는 객체를 모두 아우를 수 있게하기 위함이다.*
* 참조형으로 선언된 Base Class Object는 Derived Class Object도 참조할 수 있다. (역은 성립하지 않는다.)
※ 각각의 상속 레벨에 대한 \(\texttt{catch}\) Block이 수행할 작업을 모두 다르게 지정하고자 하는 경우,
아래 코드와 같이, \(\texttt{catch}\) Block을 상속 계층의 역순으로 정의해야 한다.
(기초 클래스 객체는 모든 파생 클래스 객체를 아우를 수 있지만, 파생 클래스 객체는 기초 클래스 객체를 받을 수 없기 때문이다.)
class bad_1 {...};
class bad_2 : public bad_1 {...};
class bad_3 : public bad_2 {...};
...
void duper() throw (bad_1) {
if(specific_cond_1)
throw bad_1();
if(specific_cond_2)
throw bad_2();
if(specific_cond_3)
throw bad_3();
}
...
try {
duper();
}
catch(bad_3& B) { ... } // 말단 파생 클래스에 대한 catch Block
catch(bad_2& B) { ... } // 중간 파생 클래스에 대한 catch Block
catch(bad_1& B) { ... } // 기초 클래스에 대한 catch Block
// 상속 레벨에 따라 catch의 동작 내용을 달리하고자 한다면,
// 위와 같이, 상속 관계의 최하단에 있는 파생 클래스에 대한 catch문부터 작성해야 한다.
※ - 넘겨받을 객체의 데이터 타입 대신, ELIPSIS(...)를 명시하여, 모든 예외를 처리하게 할 수 있다.
try {
throw specific_object_1();
}
catch(bad_3& be) { ... }
catch(bad_2& be) { ... }
catch(bad_1& be) { ... }
catch(...) { } // 괄호 안에 "..."은 ELIPSIS를 의미하는 C++예약어이다. 모든 예외를 가리지 않고 받아들인다.
// switch문의 default문과 유사한 기능을한다.
// 즉, 예외가 bad_3, bad_2, bad_1에도 해당되지 않으면 이 catch문이 동작하게 된다.
Keyword: \(\texttt{try}\)
- \(\texttt{try}\) 키워드로 정의된 \(\texttt{try}\) Block은 예외들이 발생할 수 있는 가능성이 있는 코드들이 위치하는 코드 블럭이다.
- \(\texttt{try}\) 블럭 뒤에는 하나 이상의 Exception Handler(\(\texttt{catch}\) Block)이 뒤따르게 된다.
- \(\texttt{try}\) 블럭에서 예외가 발생하지 않았다면, 뒤따르는 \(\texttt{catch}\) 블럭들은 모두 무시된다.
try {
c = division(a, b); // a / b에서 b가 0이면 예외가 발생한 것으로 처리하는 것이 바람직할 것이다.
...
}// Harmonic Mean (조화 평균) 계산 프로그램
// C++ 예외 처리 메커니즘(try - throw - catch)을 이용하여 예외상황에 대처하는 코드
#include <iostream>
double hmean(double a, double b);
int main() {
double x, y, z;
std::cout << "Enter two numbers: ";
while (std::cin >> x >> y) {
try {
// start of try block
z = hmean(x,y);
} // end of try block
catch (const char * s) {
// start of exception handler
std::cout << s << std::endl;
std::cout << "Enter a new pair of numbers: ";
continue; // catch 블록은 함수가 아니므로, 이와 같이 while문에 대한 continue문을 사용할 수 있다.
} // end of handler
std::cout << "Harmonic mean of " << x << " and " << y << " is " << z << std::endl;
std::cout << "Enter next set of numbers <q to quit>: ";
}
std::cout << "Bye!\n";
return 0;
}
double hmean(double a, double b) {
if (a == -b)
throw "bad hmean() arguments: a = -b not allowed";
return 2.0 * a * b / (a + b);
}
※ \(\texttt{throw}\)문에 일치하는 데이터 타입을 가진 \(\texttt{catch}\) Block이 없거나, \(\texttt{try}\) Block이 없으면, \(\texttt{abort()}\) 함수가 호출된다.
※ \(\texttt{return}\)문과 \(\texttt{throw}\)문의 차이
Using Objects as Exceptions (예외로써 객체 사용하기)
- 예외로써 서로 다른 데이터 타입을 사용하여 예외가 발생된 상황을 구별할 수 있다.
- 또한, 객체 자체에 예외 사항에 대한 정보를 담아 넘길 수도 있다.
// Harmonic Mean (조화 평균), geometric Mean (기하 평균) 계산 프로그램
// C++ 예외 처리 메커니즘(try - throw - catch)을 이용하여 예외상황에 대처하는 코드
// 예외로써 객체를 넘긴다.
// exc_mean.h -- exception classes for hmean(), gmean()
#include <iostream>
class bad_hmean {
private:
double v1;
double v2;
public:
bad_hmean(double a = 0, double b = 0) : v1(a), v2(b){}
void mesg();
};
inline void bad_hmean::mesg() {
std::cout << "hmean(" << v1 << ", " << v2 <<"): " << "invalid arguments: a = -b\n";
}
class bad_gmean {
public:
double v1;
double v2;
bad_gmean(double a = 0, double b = 0) : v1(a), v2(b){}
const char * mesg();
};
inline const char * bad_gmean::mesg() {
return "gmean() arguments should be >= 0\n";
}
// ---------------------------------------------------------------------
//error4.cpp – using exception classes
#include <iostream>
#include <cmath> // or math.h, unix users may need -lm flag
#include "exc_mean.h"
double hmean(double a, double b);
double gmean(double a, double b);
int main() {
using std::cout;
using std::cin;
using std::endl;
double x, y, z;
cout << "Enter two numbers: ";
while (cin >> x >> y) {
try { // start of try block
z = hmean(x,y);
cout << "Harmonic mean of " << x << " and " << y << " is " << z << endl;
cout << "Geometric mean of " << x << " and " << y << " is " << gmean(x,y) << endl;
cout << "Enter next set of numbers <q to quit>: ";
}// end of try block
catch (bad_hmean & bg) { // start of catch block
bg.mesg();
cout << "Try again.\n";
continue;
}
catch (bad_gmean & hg) {
cout << hg.mesg();
cout << "Values used: " << hg.v1 << ", " << hg.v2 << endl;
cout << "Sorry, you don't get to play any more.\n";
break;
} // end of catch block
}
cout << "Bye!\n";
return 0;
}
double hmean(double a, double b) {
if (a == -b)
throw bad_hmean(a,b);
return 2.0 * a * b / (a + b);
}
double gmean(double a, double b) {
if (a < 0 || b < 0)
throw bad_gmean(a,b);
return std::sqrt(a * b);
}
// ---------------------------------------------------------------------Exception Specifications Meet C++11 (C++11에서의 예외 사양)
- C++98에서 추가되었으며 C++11에 접어서면서 그 중요성이 떨어지고 있는 개념이다.
※ 이 개념은 추후, 표준에서 제외될 가능성이 있으므로, 가급적 사용을 자제해야 한다.
void func_1(int n) throw(bad_thing);
// 함수 func_1에서는 bad_thing 타입의 예외가 발생할 가능성이 있다.
void func_2(int n) throw();
// 함수 func_2에서는 예외를 발생시키지 않으나, 예외를 발생시키는 함수를 호출할 가능성이 있다.
void func_3(int n) noexcept;
// 함수 func_3는 예외를 발생시키지 않는다.- 위와 같은 함수 이름 끝의 throw() 문은 함수 원형 혹은 함수 정의부에서 기술될 수 있다.
- 사용자게에 try Block을 사용할 필요가 있음을 알리기 위한 명시적인 표현방법이다.
- 또한, 컴파일러가 런타임 체크용 코드를 추가하여 예외 사항이 위반되었는지에 대한 여부를 확인할 수 있게 한다.
* \(\texttt{noexcept(operand)}\) Operator
- operand가 예외를 발생시킬 수 있는지에 대한 여부를 알리는 연산자이다.
- operand가 예외를 발생하지 않는다는 보장이 있으면 \(\texttt{true}\)를 리턴하고, 그렇지 않으면 \(\texttt{false}\)를 리턴한다.
void func_A(int n);
void func_B(int n) noexcept;
...
noexcept(func_A); // false를 리턴한다.
noexcept(func_B); // true를 리턴한다.\(\texttt{exception}\) Class (\(\texttt{exception}\) 클래스)
- \(\texttt{exception}\) 클래스에 정의된 표준 예외는 아래와 같다.
- \(\texttt{bad_alloc}\)
- \(\texttt{bad_cast}\)
- \(\texttt{bad_exception}\)
- \(\texttt{bad_typeid}\)
- \(\texttt{bad_function_call}\)
- \(\texttt{bad_weak_ptr}\)
- \(\texttt{logic_error}\)
- \(\texttt{runtime_error}\)
- \(\texttt{exception}\) 헤더파일 (\(\texttt{exception.h}\) 또는 \(\texttt{except.h}\))에 정의되어 있다.
- \(\texttt{exception}\)클래스는 \(\texttt{std}\) namespace내에 분류되어 있다.
- \(\texttt{exception}\) 헤더파일에서는 \(\texttt{unexpected()}\) 함수에 의해 \(\texttt{bad_exception}\)을 사용할 수 있다.
※ 클래스 정의 시, \(\texttt{exception}\) 클래스를 상속받아서 \(\texttt{exception}\) 객체에 대한 \(\texttt{catch}\) Block을 이용해 모든 파생 객체들에 대한 예외를 한꺼번에 처리할 수 있다.
#include <exception>
class bad_hmean : public std::exception {
public:
const char * what() { return "bad arguments to hmean()"; }
...
};
class bad_gmean : public std::exception {
public:
const char * what() { return "bad arguments to gmean()"; }
...
};
try { ... }
catch(std::exception & e) {
cout << e.what() << endl;
...
}
* \(\texttt{what()}\) 메서드
- 발생한 Exception 객체의 종류를 문자열로 리턴하는, \(\texttt{exception}\) 클래스에 정의된 메서드이다.
※ 예외는 하나의 클래스이다.
- 하나의 예외 클래스를 다른 클래스로부터 파생시킬 수 있다.
- 클래스 정의 안에 예외 클래스 선언을 내포시켜 예외를 클래스에 병합시킬 수 있다.
- 내포된 예외들 또한 상속될 수 있으며, 기초 클래스의 역할을 할 수 있다.
* 예외 클래스를 내포시킨 클래스 예시
#include <stdexcept>
#include <string>
using std::string;
class Sales
{
public:
enum {MONTHS = 12}; // could be a static const
class bad_index : public std::logic_error
{ // 배열 인덱스 범위를 벗어난 값을 저장하는 클래스
// 클래스 외부에서는 Sales::bad_index
// 클라이언트 프로그램의 catch 블록에서 bad_index를 하나의 예외 객체로 사용할 수 있다.
private:
int bi; // bad index value
public:
explicit bad_index(int ix,
const std::string & s = "Index error in Sales object\n");
int bi_val() const {return bi;}
virtual ~bad_index() throw() {}
};
explicit Sales(int yy = 0);
Sales(int yy, const double * gr, int n);
virtual ~Sales() { }
int Year() const { return year; }
virtual double operator[](int i) const;
virtual double & operator[](int i);
private:
double gross[MONTHS];
int year;
};
Sales::bad_index::bad_index(int ix, const string & s )
: std::logic_error(s), bi(ix) { }
Sales::Sales(int yy)
{
year = yy;
for (int i = 0; i < MONTHS; ++i)
gross[i] = 0;
}
Sales::Sales(int yy, const double * gr, int n)
{
year = yy;
int lim = (n < MONTHS)? n : MONTHS;
int i;
for (i = 0; i < lim; ++i)
gross[i] = gr[i];
// for i > n and i < MONTHS
for ( ; i < MONTHS; ++i)
gross[i] = 0;
}
double Sales::operator[](int i) const
{
if(i < 0 || i >= MONTHS)
throw bad_index(i);
return gross[i];
}
double & Sales::operator[](int i)
{
if(i < 0 || i >= MONTHS)
throw bad_index(i);
return gross[i];
}
class LabeledSales : public Sales
{
public:
class nbad_index : public Sales::bad_index
{ // bad_index로부터 파생되며, LabeledSales 객체의 레이블을 저장 및 보고하는 기능이 추가되었다.
// 클래스 외부에서는 LabeledSales::nbad_index
private:
std::string lbl;
public:
nbad_index(const std::string & lb, int ix, const std::string & s = "Index error in LabeledSales object\n");
const std::string & label_val() const {return lbl;}
virtual ~nbad_index() throw() {}
};
explicit LabeledSales(const std::string & lb = "none", int yy = 0);
LabeledSales(const std::string & lb, int yy, const double * gr, int n);
virtual ~LabeledSales() { }
const std::string & Label() const {return label;}
virtual double operator[](int i) const;
virtual double & operator[](int i);
private:
std::string label;
};
LabeledSales::nbad_index::nbad_index(const string & lb, int ix, const string & s )
: Sales::bad_index(ix, s)
{
lbl = lb;
}
LabeledSales::LabeledSales(const string & lb, int yy)
: Sales(yy)
{
label = lb;
}
LabeledSales::LabeledSales(const string & lb, int yy, const double * gr, int n)
: Sales(yy, gr, n)
{
label = lb;
}
double LabeledSales::operator[](int i) const
{
if(i < 0 || i >= MONTHS)
throw nbad_index(Label(), i);
return Sales::operator[](i);
}
double & LabeledSales::operator[](int i)
{
if(i < 0 || i >= MONTHS)
throw nbad_index(Label(), i);
return Sales::operator[](i);
}
// use_sales.cpp -- nested exceptions
#include <iostream>
#include "sales.h"
int main()
{
using std::cout;
using std::cin;
using std::endl;
double vals1[12] =
{
1220, 1100, 1122, 2212, 1232, 2334,
2884, 2393, 3302, 2922, 3002, 3544
};
double vals2[12] =
{
12, 11, 22, 21, 32, 34,
28, 29, 33, 29, 32, 35
};
Sales sales1(2011, vals1, 12);
LabeledSales sales2("Blogstar",2012, vals2, 12 );
cout << "First try block:\n";
try
{
int i;
cout << "Year = " << sales1.Year() << endl;
for (i = 0; i < 12; ++i)
{
cout << sales1[i] << ' ';
if (i % 6 == 5)
cout << endl;
}
cout << "Year = " << sales2.Year() << endl;
cout << "Label = " << sales2.Label() << endl;
for (i = 0; i <= 12; ++i)
{
cout << sales2[i] << ' ';
if (i % 6 == 5)
cout << endl;
}
cout << "End of try block 1.\n";
}
catch(LabeledSales::nbad_index & bad)
{
cout << bad.what();
cout << "Company: " << bad.label_val() << endl;
cout << "bad index: " << bad.bi_val() << endl;
}
catch(Sales::bad_index & bad)
{
cout << bad.what();
cout << "bad index: " << bad.bi_val() << endl;
}
cout << "\nNext try block:\n";
try
{
sales2[2] = 37.5;
sales1[20] = 23345;
cout << "End of try block 2.\n";
}
catch(LabeledSales::nbad_index & bad)
{
cout << bad.what();
cout << "Company: " << bad.label_val() << endl;
cout << "bad index: " << bad.bi_val() << endl;
}
catch(Sales::bad_index & bad)
{
cout << bad.what();
cout << "bad index: " << bad.bi_val() << endl;
}
cout << "done\n";
return 0;
}※ C++98까지는 Destructor에 throw() 예외를 사용할 수 있었다.
※ C++11부터는 Destructor에 throw() 예외를 사용할 수 없게 되었다.
\(\texttt{stdexcept}\) Header File (\(\texttt{stdexcept}\) 헤더파일)
- \(\texttt{stdexcept}\) 헤더파일에는 \(\texttt{logic_error}\) Exception Family, \(\texttt{runtime_error}\) Exception Family가 정의되어 있다.
- 이 두 Exception Family는 \(\texttt{exception}\)을 \(\texttt{public}\)으로 상속받은 클래스이다.
\(\texttt{logic_error}\) Exception Class Family
- 프로그램 수정을 통해 극복이 가능한것으로 판단되는 예외들로 구성된다.
- 아래 4개의 예외는 \(\texttt{logic_error}\)에 속하는 예외들이다.
- \(\texttt{domain_error}\) Class : 기대한 범위를 넘어선 값이 함수에 전달되었을 때 예외를 발생시킨다.
- \(\texttt{invalid_argument}\) Class : 기대하지 않은 형태의 값이 함수에 전달되었을 때 예외를 발생시킨다.
- \(\texttt{length_error}\) Class : 원하는 액션을 취할 만한 충분한 공간이 확보되지 못했을 때 예외를 발생시킨다.
ex) \(\texttt{string}\) 클래스의 \(\texttt{append()}\)메서드는 특정 문자열이 최대 허용 길이를 초과했을 때 \(\texttt{length_error}\)를 발생시킨다.
- \(\texttt{out_of_bounds}\) Class : 인덱싱 에러를 감지하면 예외를 발생시킨다.
\(\texttt{runtime_error}\) Exception Class Family
- 불가피한 예외들로 구성된다.
- 아래 3개의 예외는 \(\texttt{runtime_error}\)에 속하는 예외들이다.
- \(\texttt{range_error}\) Class : 오버/언더플로우가 발생하지 않은 상태에서 치역범위를 넘어섰을 때, 예외를 발생시킨다.
- \(\texttt{overflow_error}\) Class : 오버플로우가 발생되었을 때, 예외를 발생시킨다.
- \(\texttt{underflow_error}\) Class : 언더플로우가 발생되었을 때, 예외를 발생시킨다.
※ C++ 상속 메커니즘에 따라, 계층적으로 Exception Class Family를 아우르는 \(\texttt{catch}\) Block 또한 충분히 작성 가능하다.
try {
...
}
catch(out_of_bounds & oe) // catch out_of_bounds error
{...}
catch(logic_error & oe) // catch remaining logic_error family
{...}
catch(exception & oe) // catch runtime_error, exception objects
{...}bad_alloc Exception
- C++ 시스템에서 메모리 할당에 문제가 발생한 경우에 발생시키는 예외이다.
- bad_alloc 클래스는 exception 클래스를 public으로 상속받은 클래스이다.
- bad_alloc 클래스는 new 헤더파일 (또는 new.h)에 정의되어 있다.
* C++에서는 메모리 할당 시, 문제가 발생했을 때 두 가지 방법으로 대처한다.
1. new가 null을 리턴한다.
2. bad_alloc 예외를 발생시킨다.
- 컴파일러 스위치 등과 같은 방법을 통해 둘 중 하나를 Default로 세팅할 수 있다.
* 예외 발생 시, new가 null을 리턴하도록 하는 Flag 설정법
- new에 nothrow를 설정한다.
int* pi = new(std::nothrow) int;
if(pi == 0){
cout << "Rejected Allocation" << std::endl;
...
}
* bad_alloc 핸들링 예시
// newexcp.cpp -- the bad_alloc exception
#include <iostream>
#include <new>
#include <cstdlib> // for exit(), EXIT_FAILURE
using namespace std;
struct Big
{
double stuff[20000];
};
int main()
{
Big* pb;
try {
cout << "Trying to get a big block of memory:\n";
pb = new Big[1000000000];
cout << "Got past the new request:\n";
}
catch (bad_alloc& ba)
{
cout << "Caught the exception!\n";
cout << ba.what() << endl;
exit(EXIT_FAILURE);
}
cout << "Memory successfully allocated\n";
pb[0].stuff[0] = 4;
cout << pb[0].stuff[0] << endl;
delete[] pb;
return 0;
}Unexpected Exception (기대하지 않은 예외)
- throw()나 noexcept와 같은 Exception Specification(예외 사양)에 지정되어 있지 않은 곳에서 예외가 발생한 경우를 의미한다.
- 감지되면, 프로그램 실행을 중지시킨다.
- 함수에 Exception Specification(예외 사양, 예외 지정)을 사용함으로써, 해당 함수를 사용하는 사용자들은 그 함수에서 어떤 예외들이 발생할 수 있는지를 사전에 알 수 있다.
double Argh(double, double) throw(out_of_bound);
// 여기서 throw(out_of_bound) 구문이 예외 사양에 해당된다.
// Argh() 함수에서는 out_of_bound 타입의 예외가 발생될 수 있음을 의미한다.
try {
x = Argh(a, b);
}
catch (out_of_bound& ex) { // Argh() 함수에서 발생할 수 있는 out_of_bound 예외에 대비한다.
...
}
※ 원칙적으로, 예외 지정에는 해당 함수에서 발생될 수 있는 모든 예외들이 명시되어야 한다.
- 가령, A() 함수에서는 a라는 예외가 발생할 수 있고, B() 함수에서는 b라는 예외가 발생할 수 있으며, A() 함수에서 B() 함수를 호출한다고 하면, A() 함수에서의 예외 지정에는 a와 b에 대한 예외 지정이 모두 이루어져야 한다는 뜻이다.
- 이는 예외 규격 메커니즘이 좁은 범뮈내에서 사용되어야 함을 의미한다.
- 이러한 점으로 인해, C++11에서 예외 규격(예외 지정) 개념을 제외하고자 하는 것이다.
* Unexpected Exception가 발생하면, 프로그램은 unexcepted() 함수를 호출한다.
- unexcepted() 함수는 기본적으로 terminate() 함수를 호출하고,
terminate() 함수는 기본적으로 abort() 함수를 호출한다.
- set_unexcepted() 함수를 통해, unexcepted() 함수의 동작을 변경할 수 있다.
- 특히, set_unexcepted() 함수는 set_terminate() 함수보다 더욱 세밀하게 제어할 수 있다.
- 위 함수들 모두 exception 헤더파일에 선언되어 있다.
typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler f) throw(); // C++98
unexpected_handler set_unexpected(unexpected_handler f) noexcept; // C++11
void unexpected(); // C++98
void unexpected() noexcept; // C++0x
* unexcepted_handler 함수는 아래와 같은 기능을 할 수 있다.
1. terminate() 함수(디폴트), abort() 함수, exit() 함수로 대체되어 프로그램을 종료시킬 수 있다.
2. 예외를 발생시킬 수 있다.
- 발생한 예외가 예외 지정에 일치하면, 그에 대응되는 catch Block을 찾는다.
- 발생한 예외가 예외 지정에 일치하지는 않으나, 예외 지정에 std::bad_exception형이 명시되어 있으면,
해당 예외는 bad_exception형 예외로 간주된다.
- 발생한 예외가 예외 지정에 일치하지 않고, 예외 지정에 std::bad_exception형조차 명시되어 있지 않으면,
프로그램은 terminate() 함수를 호출한다.
* unexcepted_handler 함수가 예외를 발생시키고, 이를 적절히 처리하는 구조
#include <exception> // 예외에 관련된 여러가지가 정의되어 있다.
void myUnexcepted() {
throw std::bad_exception(); // throw;문만 적어도 무방하다.
}
...
set_unexcepted(myUnexpected);
...
double Argh(double, double) throw(out_of_bounds, bad_exception);
...
try {
x = Argh(a, b);
}
catch (out_of_bound& ex) {
// out_of_bound형 예외에 대한 대처사항
}
catch (bad_exception& ex) {
// bad_exception형 예외에 대한 대처사항
}Uncaught Exception (포착되지 않은 예외)
- try Block 밖에서 발생되거나, 어떠한 catch Handler와도 매치되지 않는 예외가 발생된 경우를 의미한다.
- 감지되면 terminate() 함수를 호출하며, 프로그램을 즉각 중단시키지 않는다.
- terminate() 함수는 기본적으로 abort() 함수를 호출하며, abort() 함수 대신, 다른 함수를 호출하도록 변경할 수 있다.
- terminate() 함수가 호출하는 함수는 set_terminate() 함수를 이용하여 바꿀 수 있다.
- terminate() 함수와 set_terminate() 함수는 exception 헤더파일에 선언되어 있다.
typedef void (*terminate_handler)();
// terminate_handler : 매개변수를 사용하지 않고, 리턴값도 없는 함수를 가리키는 포인터를 위한 데이터형
terminate_handler set_terminate(terminate_handler f) throw(); // C++98
terminate_handler set_terminate(terminate_handler f) noexcept; // C++11
// set_terminate() 함수는
// 매개변수를 사용하지 않고 리턴형이 void인 함수(terminate_handler 타입)의 이름(=주소)을 매개변수로 사용한다.
// 이전에 등록된 함수의 주소를 리턴한다.
// set_terminate() 함수가 한 번 이상 호출되면,
// terminate() 함수는 가장 최근의 set_terminate() 함수 호출에 의해 설정된 함수를 호출한다.
void terminate(); // C++98
void terminate() noexcept; // C++11
// 예외가 발생했으나, 포착되지 않으면, 프로그램은 terminate() 함수를 호출한다.
// terminate() 함수는 기본적으로 abort() 함수를 호출하게 되어있다.
// set_terminate() 함수를 이용하여 terminate() 함수가 abort() 함수 대신, 다른 함수를 호출하게 할 수 있다.
* 시스템은 Uncaught Exception가 발생하면, terminate() 함수를 호출하고,
사용자의 의도에 따라 terminate() 함수는 myQuit() 함수를 호출한다.
void myQuit() {
std::cout << "포착되지 않은 예외가 발생하여 프로그램을 중지시킵니다.\n";
exit(5);
}
...
set_terminate(myQuit); // 프로그램의 시작 부분에 위치해야 한다.Exception Cautions (예외 주의사항)
* 예외의 단점
- 예외를 사용함으로써 프로그램의 크기가 커지고, 실행속도를 저해한다.
- 예외 지정은 템플릿 개념과 어울리지 않는다.
(템플릿을 통한 여러 종류의 특수화로 인해 여러 종류의 예외가 발생될 수 있기 때문이다.
즉, 템플릿 기능은 발생될 예외의 예측을 어렵게 하기 때문이다.)
- 예외는 동적 메모리 할당 개념과 어울리지 않는다.
(메모리 반납이 이루어지기 전에, 예외가 발생되어 throw문이 실행되고 프로그램이 종료되면,
반납되지 못한 메모리로 인한 Memory Leak이 발생한다.
void test2(int n) {
double* ar = new double[n];
...
if (oh_no)
throw exception(); // 메모리 반납 이전에 예외가 발생되면, throw문으로 인해 프로그램이 종료된다.
...
delete[] ar; // 메모리 반납
return;
}
* 프로그래머가 Memory Leak에 대비하여, catch Block에 따로 메모리 반납 코드를 삽입함으로써,
예외 처리로 인한 Memory Leak을 방지할 수 있다.
void test3(int n) {
double * ar = new double[n];
...
try {
if (oh_no)
throw exception();
}
catch(exception & ex)
{
delete [] ar; // 예외가 발생한 경우의 메모리 해제 코드
throw;
}
...
delete [] ar; // 예외가 발생되지 않은 경우의 메모리 해제 코드
return;
}- 이 방법은 프로그래머의 실수로 해제를 빠뜨리거나, 다른 에러를 발생시킬 가능성이 있어 완벽한 해결책이라 할 수 없다.
- 이에 대한 해결책으로, auto_ptr 템플릿이 있다.