Table of Contents
This part 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.
C++ has the following builtin types:
char
signed char
unsigned char
signed short
signed int
signed long
unsigned short
unsigned int
unsigned long
bool
wchar_t
float
double
long double
These fundamental types are always available, without having to include a header file. These types are exactly the same in either C++ or in C.
Specializing parts of the library on these types is prohibited: instead, use a POD.
The header limits defines
traits classes to give access to various implementation
defined-aspects of the fundamental types. The traits classes --
fourteen in total -- are all specializations of the class template
numeric_limits
and 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;
};
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.
For 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.
See the Effective C++ CD example.