StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
17391495
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2013-06-30T14:39:57.713
FavoriteCount
0
LastActivityDate
2013-06-30T15:08:31.903
LastEditDate
2013-06-30T15:08:31.903
LastEditorUserId
777186
OwnerUserId
777186
ParentId
17391071
PostTypeId
2
Score
2
ViewCount
0
LastEditorDisplayName
text
Body
"Throwing an exception" (sometimes also called "raising an exception") is a way to end a function when, for some reason, the function cannot complete the task it is expected to complete. Example: You have a function <code>f</code> that takes a <code>float</code> argument and is expected to compute and return its natural logarithm. Now at some point during the calculations it turns out that the argument that it was passed is <code>0</code>. There is no way to compute the logarithm of <code>0</code>, so what should the function do? One way to handle this situation is to return a special value (such as <code>NaN</code>, the not-a-number value of <code>float</code>), but this can be misleading to the caller of the function: The function was called on some variable, and returned some value. All looks normal, while in reality nothing is normal – the function could not do its job. Therefore, another way of handling this is to throw an exception. The effect is that the function ends, but does not return any value. Now, obviously, the calling function has a problem, because the normal flow of things has been disturbed: No value was returned from the function call. There are two possibilities for what can happen next: Either the calling function was prepared for this by having put the call of <code>f</code> in a try-catch clause: <pre><code>try { log_of_val = f(val); } catch (const exception &e) { /* Description of what to do when an exception is thrown by f. */ } </code></pre> If the exception that is thrown by <code>f</code> matches the type of exception defined in one of the catch-clauses, then the first such catch-clause is executed. If there is no such catch-clause, the exception is thrown again, i.e. the calling function also ends abruptly and the caller of the caller is stopped to check whether there is some catch-code for the exception. If not, it also ends and that functions calling function is stopped, and so on, until the top of the call stack is reached (i.e. the level of <code>main</code>) and if there is still no catch-clause there, the entire program is terminated and the operating system is informed of the abortion of the process. So an exception has the power to bring down the entire process if there is no appropriate catch-clause. But an exception is far better than simply calling something like <code>exit(1)</code>, because it does not immediately terminate the process. It first gives the caller a chance to react to the problem, and then the caller's caller, and so on. The exception throwing mechanism also ensures that local variables are properly destructed and de-allocated before the current function ends. So, as far as automatic variables and dynamic memory that is managed by smart pointers and the like is concerned, you won't get memory leaks and similar problems. To sum up, exceptions (and the whole throwing and catching mechanism) is a way to deal with unusual, but possible and to some extent expected events in the flow of a program. Typically, it's events that can occur in a function call that render the proper execution of the function impossible, but that cannot be prevented from within the function. These events are often the responsibility of the calling function if it passes unsuitable arguments, or of the user who gives unsuitable input to the program. Also problems related to the state of the system, such as insufficient memory, tend to be handled by throwing exceptions. But unlike bugs, the programmer who wrote a function anticipated the possiblility of the problem and prepared the code with suitable throw and catch code to deal with it by having the program shut down in a controlled way, or otherwise react to the problem appropriately. Regarding the core of your question: What is the exception itself? The exception is an object created at the time when the "exception is thrown". You could view it as some kind of replacement for the return value, because the exception object is in fact passed to the caller, in a similar way as the return value would. But unlike with an actual return value, the caller is informed that what has happened is an exception and that it must handle this in the way I've described above. Further more, the data type of the exception is not the data type declared as return type of the function. In fact, it can be (almost) any data type. In particular, it can be a complex object with member variables that are initialized with values that describe the circumstances of the exception. A typical exception object is C++ is of class type, often (but not necessarily) defined as something like this: <pre><code>#include <exception> class my_exception : public std::exception { public: explicit my_exception(const char *description) : std::exception() , description_(description) { } virtual const char *what() const noexcept { return description_; } private: const char *description_; }; </code></pre> So it's a user-defined object that is constructed on a string, stores a pointer to the string internally, and provides a member function <code>what()</code> that returns the string. The idea is that the string is defined when the exception is thrown, and that it contains some description of the problem. The caller of <code>f</code> can then catch this type of exception by enclosing the call to <code>f</code> in a try-clause and adding a catch-clause for <code>my_exception</code>: <pre><code>try { f(); } catch (const my_exception &e) { std::cerr << "A problem has occurred when evaluating f(): " << e.what() << std::endl; } </code></pre> In this example, we use the exception object's <code>what()</code> function to print a description of the problem. After the catch-clause is completed, the caller will continue as normal. (If this is not desired, <code>throw;</code> can be used inside the catch-clause to re-throw the exception so it is passed to the caller's caller, and so on.) Note, again, that exception can be user-defined objects, and they can be derived from <code>std::exception</code>, and they can override the <code>what()</code> function to return a problem description as a string, but none of this is necessary. You can also throw the string itself, or an <code>int</code> as exception.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhat is an exception?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USjogojapan
UserOwnerUserId
1. USjogojapan
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. This table or related slice is empty.

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.