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.
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.
In g++, NULL is #define'd to be __null, a magic keyword extension of g++.
The biggest problem of #defining NULL to be something like "0L" is that the compiler will view that as a long integer before it views it as a pointer, so overloading won't do what you expect. (This is why g++ has a magic extension, so that NULL is always a pointer.)
In his book Effective C++, Scott Meyers points out that the best way to solve this problem is to not overload on pointer-vs-integer types to begin with. He also offers a way to make your own magic NULL that will match pointers before it matches integers:
const // this is a const object... class { public: template<class T> // convertible to any type operator T*() const // of null non-member { return 0; } // pointer... template<class C, class T> // or any type of null operator T C::*() const // member pointer... { return 0; } private: void operator&() const; // whose address can't be // taken (see Item 27)... } NULL; // and whose name is NULL(Cribbed from the published version of the Effective C++ CD, reproduced here with permission.)
If you aren't using g++ (why?), but you do have a compiler which supports member function templates, then you can use this definition of NULL (be sure to #undef any existing versions). It only helps if you actually use NULL in function calls, though; if you make a call of foo(0); instead of foo(NULL);, then you're back where you started.
Added Note: When we contacted Dr. Meyers to ask permission to print this stuff, it prompted him to run this code through current compilers to see what the state of the art is with respect to member template functions. He posted an article to Usenet after discovering that the code above is not valid! Even though it has no data members, it still needs a user-defined constructor (which means that the class needs a type name after all). The ctor can have an empty body; it just needs to be there. (Stupid requirement? We think so too, and this will probably be changed in the language itself.)
Return to top of page or to the FAQ.
<limits>
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.
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:
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.
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:
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 news" 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.7 2000/12/03 23:47:47 jsm28 Exp $