# Chapter 18: Library Support

Chapter 18 deals with the functions called and objects created automatically during the course of a program's existence.

While we can't reproduce the contents of the Standard here (you need to get your own copy from your nation's member body; see our homepage for help), we can mention a couple of changes in what kind of support a C++ program gets from the Standard Library.

# Contents

- Types
- Implementation properties
- Start and Termination
- Dynamic memory management

## Types

All the types that you're used to in C are here in one form or another. The only change that might affect people is the type of NULL: while it is required to be a macro, the definition of that macro is not allowed to be `(void*)0`, which is often used in C.

Return to top of page or to the FAQ.

## Implementation properties

### `<limits>`

This header mainly defines traits classes to give access to various implementation defined-aspects of the fundamental types. The traits classes -- fourteen in total -- are all specilizations of the template class `numeric_limits` defined as follows:

       template<typename T> struct class {
          static const bool is_specialized;
          static T max() throw();
          static T min() throw();

          static const int digits;
          static const int digits10;
          static const bool is_signed;
          static const bool is_integer;
          static const bool is_exact;
          static const int radix;
          static T epsilon() throw();
          static T round_error() throw();

          static const int min_exponent;
          static const int min_exponent10;
          static const int max_exponent;
          static const int max_exponent10;

          static const bool has_infinity;
          static const bool has_quiet_NaN;
          static const bool has_signaling_NaN;
          static const float_denorm_style has_denorm;
          static const bool has_denorm_loss;
          static T infinity() throw();
          static T quiet_NaN() throw();
          static T denorm_min() throw();

          static const bool is_iec559;
          static const bool is_bounded;
          static const bool is_modulo;

          static const bool traps;
          static const bool tinyness_before;
          static const float_round_style round_style;
       };

Return to top of page or to the FAQ.

## Start and Termination

Not many changes here to `<cstdlib>` (the old stdlib.h). You should note that the `abort()` function does not call the destructors of automatic nor static objects, so if you're depending on those to do cleanup, it isn't going to happen. (The functions registered with `atexit()` don't get called either, so you can forget about that possibility, too.)

The good old `exit()` function can be a bit funky, too, until you look closer. Basically, three points to remember are:

1. Static objects are destroyed in reverse order of their creation.
2. Functions registered with `atexit()` are called in reverse order of registration, once per registration call. (This isn't actually new.)
3. The previous two actions are "interleaved," that is, given this code:

                     extern "C or C++" void  f1 (void);
                     extern "C or C++" void  f2 (void);

                     static Thing obj1;
                     atexit(f1);
                     static Thing obj2;
                     atexit(f2);

   then at a call of `exit()`, f2 will be called, then obj2 will be destroyed, then f1 will be called, and finally obj1 will be destroyed. If f1 or f2 allow an exception to propogate out of them, Bad Things happen.

Return to top of page or to the FAQ.

## Dynamic memory management

There are six flavors each of `new` and `delete`, so make certain that you're using the right ones! Here are quickie descriptions of `new`:

- single object form, throwing a `bad_alloc` on errors; this is what most people are used to using
- single object "nothrow" form, returning NULL on errors
- array new, throwing `bad_alloc` on errors
- array nothrow new, returning NULL on errors
- placement new, which does nothing (like it's supposed to)
- placement array new, which also does nothing

They are distinguished by the parameters that you pass to them, like any other overloaded function. The six flavors of `delete` are distinguished the same way, but none of them are allowed to throw an exception under any circumstances anyhow. (They match up for completeness' sake.)

Remember that it is perfectly okay to call `delete` on a NULL pointer! Nothing happens, by definition. That is not the same thing as deleting a pointer twice.

By default, if one of the "throwing `new`s" can't allocate the memory requested, it tosses an instance of a `bad_alloc` exception (or, technically, some class derived from it). You can change this by writing your own function (called a new-handler) and then registering it with `set_new_handler()`:

       typedef void (*PFV)(void);

       static char*  safety;
       static PFV    old_handler;

       void my_new_handler ()
       {
           delete safety;
           popup_window ("Dude, you are running low on heap memory.  You
                          should, like, close some windows, or something.
                          The next time you run out, we're gonna burn!");
           set_new_handler (old_handler);
           return;
       }

       int main ()
       {
           safety = new char[500000];
           old_handler = set_new_handler (&my_new_handler);
           ...
       }

`bad_alloc` is derived from the base `exception` class defined in Chapter 19.

Return to top of page or to the FAQ.

Comments and suggestions are welcome, and may be sent to Phil Edwards or Gabriel Dos Reis.
$Id: howto.html,v 1.5 1999/12/15 16:57:06 pme Exp $