Chapter 4. Support

Chapter 4. + Support + +
Prev	Part II. + Standard Contents +	Next

+ 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. +

Types

Fundamental Types

+ 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. +

Numeric Properties

+ 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 template class + numeric_limits, documented here + 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;
+     };
+

NULL

+ 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 +