Prev: Look-up table with anonymous functions
Next: C++ language: Cloneable classes
From: Alberto Ganesh Barbati on 6 May 2008 09:20
Johan Torp ha scritto:
> IIRC, the standard library avoids throwing exceptions so that users
> which compile without exception support shall be able to use as much
> of the standard library as possible. Is this correct, incorrect or are
> there other motivations?

That is not entirely correct. There are several situations where the
library is expected/required to throw an exception. In fact there is a
whole hierarchy of exception classes for that purpose. The library
avoids throwing exceptions in all places where "failure" is not
considered an "error" (for example: std::find) and in few other places.
There are also a few places where exceptions are not thrown and
behaviour is left undefined in case of error. This is usually done for
sake of performances (for example: std::vector<>::operator[]) or to
avoid over-constraining the implementation (std::tr1::shared_from_this).

> Will this also be the case for the newly accepted libraries and for
> TR2?

It's likely that the same approach described above will be followed for TR2.

> Will this "undefined behaviour"-strategy only apply to broken pre-
> conditions or will error codes and the like be used for reporting
> internal errors?

There is no "undefined behaviour"-strategy. The standard clearly states
when the behaviour is defined and when it isn't. If the behaviour is
defined the standard clearly states if an exception shall be thrown or
if an error condition is reported in some other way. If the behaviour is
undefined, which is usually the case when a precondition is not
satisfied, anything can happen: the implementation might ignore or
report the problem, an exception might be thrown or the application
might crash or anything else.

HTH,

Ganesh

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

From: Pete Becker on 6 May 2008 03:45
On 2008-05-06 04:43:26 -0400, Johan Torp <johan.torp(a)gmail.com> said:

> IIRC, the standard library avoids throwing exceptions so that users
> which compile without exception support shall be able to use as much
> of the standard library as possible. Is this correct,

No. The standard library is specified for the standard language.

> incorrect or are
> there other motivations?
>
> Will this also be the case for the newly accepted libraries and for
> TR2?
>
> Will this "undefined behaviour"-strategy only apply to broken pre-
> conditions or will error codes and the like be used for reporting
> internal errors?
>

The standard library doesn't "avoid throwing exceptions". In general,
the design is to throw exceptions when they're appropriat, and not
throw exceptions when they aren't. Most cases of undefined behavior
occur because the violation of the rule can't easily be detected.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

 | 
Pages: 1
Prev: Look-up table with anonymous functions
Next: C++ language: Cloneable classes