이 강좌에서 설명하는 예외처리는 ANSI C++ 표준에 의해 제시된 공인된 새로운 표준에 대한 내용이다. 만약 이 표준을 제공하지 않는 컴파일러를 사용한다면, 이 기능을 실습할 수 없음을 밝힌다. 일반적으로 컴파일러 자체의 예외처리 문법을 가지고 있는 경우가 많고, 그것을 사용하는 것이 더 좋을 수 있다. Visual C++이나 C++ Builder와 같은 상업적으로 유명한 개발툴들과 g++과 같은 툴은 표준 예외처리를 제공한다.

프로그램을 개발하는 중에는, 제대로 실행되고 있는 코드인지를 확신할 수 없는 경우, 또는 존재하지 않는 자원을 억세스하려한다거나, 지정한 범위를 넘어서서 처리되는 경우등등과 같은 일들이 생길 수 있다.

이런 형태의 비정상적인 상황때문에 예외처리를 사용하는 것이다. C++은 이런 상황에 대처하기 위해 3가지의 새로운 연산자(try, throw, catch)를 제공한다.

이 연산자의 대략적인 형태는 다음과 같다.:

try {
  // 예외가 발생할 지 모르는 코드 부분
  throw exception; // 예외가 발생되어야 할 경우 예외발생
}
catch (type exception)
{
  // 각각의 예외에 따라 실행되어야 하는 코드들
}

각각의 역할 및 동작은 다음과 같다:

• try 블럭내의 코드는 정상적으로 실행된다. 만일 지정한 블럭내에서 예외를 발생해야 할 경우, throw 키워드를 사용한다. throw 키워드에 따른 인자는 어떤 경우에 대한 예외인가를 나타낸다.
• 만약 예외가 발생하거나 throw 키워드가 실행되면, catch 블럭이 발생한 예외를 나타내는 인자와 함께 실행되게 된다.
  
  

예를 들자면 다음과 같다.:

// exceptions
#include <iostream.h>

int main () {
  char myarray[10];
  try
  {
    for (int n=0; n<=10; n++)
    {
      if (n>9) throw "범위를 벗어남!";
      myarray[n]='z';
    }
  }
  catch (char * str)
  {
    cout << "예외발생 : " << str << endl;
  }
  return 0;
}

이 예제는 for 루프안에서 n이 9이상이 되면 예외가 throw하도록 작성되어있다. (왜냐하면, myarray가 10개의 인자를 가진 배열로 선언되어있으므로 인덱스가 9초과인 수가 지정되면 점근할 수없는 메모리를 억세스 하는 것이 되기 때문이다.) throw가 실행되면 루프와는 상관없이 catch 블럭내의 코드가 실행된다. 그리고 catch 블럭 아래가 실행되기 시작한다. (여기서는 그냥 0을 반환한다.

throw에 의해 사용된 문법은 마치 return 키워드와 비슷하다. 단지 ( ) 내에 들어갈 수 있는 형태의 한개의 값만을 지정할 수 있다는 것만 기억해두자.

catch 블럭은 반드시 try 블럭에 인접해서 선언되어야만 한다. (둘 사이에 코드가 삽입되면 안된다) catch 문이 받아들일 수 있는 인자는 어떤 적법한 타입도 상관없다. 여러 개를 지정할 때에는 catch는 서로 다른 타입의 인자로서 중첩선언될 수 있다. 이런 경우는 try 블럭내에서 해당 throw 타입에 맞는 catch 블럭만 실행된다:

// 예외처리 : 다중 catch 블럭
#include <iostream.h>

int main () {
  try
  {
    char * mystring;
    mystring = new char [10];
    if (mystring == NULL) throw "할당 실패!";
    for (int n=0; n<=100; n++)
    {
      if (n>9) throw n;
      mystring[n]='z';
    }
  }
  catch (int i) // 예외 1
  {
    cout << "예외 1 : ";
    cout << "인덱스 " << i << " 번은 범위를 벗어난 것임!" << endl;
  }
  catch (char * str) // 예외 2
  {
    cout << "예외 2 : " << str << endl;
  }
  return 0;
}

위 코드와 같은 경우는 적어도 2가지의 예외가 발생할 가능성이 있다:

1. 10개의 문자에 대한 메모리가 할당되지 않았을 경우(거의 일어나기 힘들지만, 가능은 하다) : 예외 2번이 발생한다.
2. mystring의 인덱스 지정이 최대치(9)를 넘었을 경우 : 예외 1번이 발생한다.
   
   

또한 catch 블럭이 throw로 던져지는 특정 예외 타입에 종속되지 않고, 모든 예외를 수용할 수 있도록 정의할 수 있다. (처음 문법을 보면 의아해할 수도 있지만, ^^) 인자 대신 ...이라고 넣으면 된다:

try {
  // 실행코드부분
}
catch (...) {
  cout << "무언지 모르지만, 예외발생!";
}

It is also possible to nest try-catch blocks within more external try blocks. In these cases, we have the possibility that an internal catch block forwards the exception received to the external level, for that it is used the expression throw; with no arguments. For example:

try {
  try {
      // 실행코드부분
  }
  catch (int n) {
      throw;
  }
}
catch (...) {
  cout << "예외발생!";
}

만약 맞는 catch 타입이 없어서 지정한 catch 문장들에 대해 예외가 잡히지 않았다면, 특별한 terminate라는 함수가 실행된다. 이 함수는 일반적으로 현재 프로세스를 종료하고, "Abnormal Termination"에러를 출력한다. 그 함수 정의는 다음과 같다:

void terminate();

Some functions of the standard C++ language library send exceptions that can be captured if we include them within a try block. These exceptions are sent with a class derived from std::exception as type. This class (std::exception) is defined in the C++ standard header file <exception> and serves as pattern for the standard hierarchy of exceptions:

exception

• bad_alloc (thrown by new)
• bad_cast (thrown by dynamic_cast when fails with a referenced type)
• bad_exception (thrown when an exception doesn't match any catch)
• bad_typeid (thrown by typeid)
• logic_error
  • domain_error
  • invalid_argument
  • length_error
  • out_of_range
• runtime_error
  • overflow_error
  • range_error
  • underflow_error

ios_base::failure (thrown by ios::clear)

Because this is a class hierarchy, if you include a catch block to capture any of the exceptions of this hierarchy using the argument by reference (i.e. adding an ampersand & after the type) you will also capture all the derived ones (rules of inheritance in C++).

The following example catches an exception of type bad_typeid (derived from exception) that is generated when requesting information about the type pointed by a null pointer:

// standard exceptions

#include <iostream.h>
#include <exception>
#include <typeinfo>

class A {virtual f() {}; };

int main () {
  try {
    A * a = NULL;
    typeid (*a);
  }
  catch (std::exception& e)
  {
    cout << "Exception: " << e.what();
  }
  return 0;
}

예외에 대한 표준 상속 클래스들을 사용할 수 있을 것이다. 이렇게 함으로써 개발자만의 예외를 던질 수 있다던가, 새로운 예외상황을 상속받아 만들 수 있게 된다.

예외는 C++의 강력한 기능 중 하나이고, 디버깅이나 다운되지 않는 방어적인 프로그램을 제작할 때에 상당히 강력한 역할을 수행할 수 있다. 하지만, 개인적으로는 자주 쓰지 않는데 그 이유는 다음과 같다. (주관적인 것임을 밝힌다.)

1. 방어적인 코드라기 보다는 에러가 잠재되어있는 코드를 뒷처리하는 경우에 사용되는 것이 보통이지만, 이런 경우 그 에러를 완벽하게 뒤처리 못하는 경우가 많다. 심지어 그냥 프로그램을 리셋할 경우가 많은데, 이럴때는 차라리 assert가 더 편리하다.
2. 프로그램을 모듈화하기 힘들게 된다. 예외란 것은 언제나 일정 코드영역을 싸고 있는 형태를 취하므로, 특정 클래스들의 맴버함수들에 걸쳐서 일어나는 버그같은 것에는 대처하기가 상당히 어렵다.
3. 코드량이 늘어난다. (따라서 귀찮다. ^^) 게다가 나중에 일시적인 버그로 밝혀졌을 때에는 쉽게 고칠 수 없다. (catch부분의 코드가 아까워질 수 있다. -_-;)
4. 내부적으로 스택을 사용하므로 너무 중첩적으로 사용하면 곤란하다.
5. 여러 예외가 중첩적으로 일어날 경우(try내부에 또 try...이런 식일 경우) 잘못 작성하면 어느 예외가 발생했는지조차 헛갈릴 수 있다. 다시말하면, 중급이상의 활용에서는 약간의 트릭이 필요하다. (위 "표준 예외의 활용" 참조)
   
   

이제는 사용하면 괜찮은 경우를 들어보겠다. (역시 주관적. ^^)

1. 특정 소스라인이 아닌 블럭내에서 프로그램 실행이 멈출정도의 에러가 발생할 가능성이 있지만, 프로그램이 계속 실행되어야만 할 경우를 들 수 있다. (0으로 나눌경우가 대표적인 예이다. 이때에는 1로만 바꾸어줘도 극복이 가능하다.)
2. 특정 라이브러리는 아예 내부적으로 예외를 정해서 에러가 발생하면 그에 따른 예외를 실행하도록 되어있는 경우가 있다. (ACE가 대표적인 예이다) 이때에는 예외를 공부해두는 것이 좋다.
3. 자신만의 라이브러리를 제작할 경우, 표준 예외를 상속해서 몇가지 예외를 선언해두고 활용하면 라이브러리를 사용하는 쪽에서 편리할 수 있다. 예외를 클래스로 줄 수 있다는 것은 상당히 강력한 개념이므로 확실히 알아두는 것이 좋다.
   
   

특히 중요한 것은 catch 부분에 개발 중인 중요한 처리 코드를 넣는 것은 가급적 하지 않는 것이 좋다. 예외처리도 디버그용이므로 버그가 없다고 판단되면 지우게 되는 코드라는 점을 명심하기 바란다. 그리고 일시적이고 복구가 힘든 에러(불행히도 이런 경우가 대부분이다)는 assert를 사용하는 것이 편리하다라는 것을 알아두기 바란다.