- 论坛徽章:
- 0
|
3.3.3 Throwing Standard Exceptions
You can throw standard exceptions inside your own library or program. All standard exception
classes that enable you to do this have only one parameter to create the exception: a string
(class string is described in Chapter 11) that will become the description returned by
what(). For example, the class logic_error is defined as follows:
namespace std {
class logic_error : public exception {
public:
explicit logic_error (const string& whatString);
};
}
The set of standard exceptions that provide this ability contains class logic_error and its
derived classes, class runtime_error and its derived classes, as well as class
ios_base::failure. Thus, you can't throw exceptions of the base class exception and any
exception class that is provided for language support.
To throw a standard exception, you simply create a string that describes the exception and use it
to initialize the thrown exception object:
string s;
...
throw out_of_range(s);
Implicit conversions from char* to string exist, so you can also use a string literal directly:
throw out_of_range("out_of_range exception (somewhere, somehow)" ;
3.3.4 Deriving Standard Exception ClassesAnother possibility for using the standard exception classes in your code is to define a special
exception class derived directly or indirectly from class exception. To do this, you must ensure
that the what() mechanism works.
The C++ Standard Library
dyne-book 34
The member function what() is virtual. So, one way to provide what() is to write your own
implementation of what():
namespace MyLib {
/* user-defined exception class
* derived from a standard class for exceptions
*/
class MyProblem : public std::exception {
public:
...
MyProblem(...) { //special constructor
}
virtual const char* what() const throw() {
//what() function
...
}
};
...
void f() {
...
//create an exception object and throw it
throw MyProblem(...);
...
}
}
Another way to provide the what() function is to derive your exception class from one of the
classes that have a string constructor for the what() argument:
namespace MyLib {
/* user-defined exception class
* - derived from a standard class for exceptions
* that has a constructor for the what() argument
*/
class MyRangeProblem : public std: ut_of_range {
public:
MyRangeProblem (const string& whatString)
: out_of_range(whatString) {
}
};
...
void f() {
...
//create an exception object by using a string constructor
and throw it
throw MyRangeProblem("here is my special range problem";
...
}
}
For examples that are part of a complete program, see class Stack on page 441 and class
Queue on page 450.
[ 本帖最后由 fibbery 于 2008-8-11 16:53 编辑 ] |
|
免费注册
楼主: fibbery
发表于 2008-08-11 16:40
