| blob | eff1c75bebf4c4f6c985792fe86b672dab56c790 |
2 <!DOCTYPE html
3 PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
7 <head>
23 </head>
24 <body>
29 automatically during the course of a program's existence.
30 </p>
31 <p>While we can't reproduce the contents of the Standard here (you need to
32 get your own copy from your nation's member body; see our homepage for
33 help), we can mention a couple of changes in what kind of support a C++
34 program gets from the Standard Library.
35 </p>
38 <!-- ####################################################### -->
39 <hr />
41 <ul>
48 </ul>
50 <hr />
52 <!-- ####################################################### -->
55 <p>All the types that you're used to in C are here in one form or
56 another. The only change that might affect people is the type of
57 NULL: while it is required to be a macro, the definition of that
59 often used in C.
60 </p>
62 extension of g++.
63 </p>
64 <p>The biggest problem of #defining NULL to be something like
66 before it views it as a pointer, so overloading won't do what you
67 expect. (This is why g++ has a magic extension, so that NULL is
68 always a pointer.)
69 </p>
70 <p>In his book
72 Scott Meyers points out that the best way to solve this problem is to
73 not overload on pointer-vs-integer types to begin with. He also
74 offers a way to make your own magic NULL that will match pointers
75 before it matches integers:
76 </p>
77 <pre>
78 const // this is a const object...
79 class {
80 public:
82 operator T*() const // of null non-member
83 { return 0; } // pointer...
86 operator T C::*() const // member pointer...
87 { return 0; }
89 private:
90 void operator&() const; // whose address can't be
91 // taken (see Item 27)...
93 } NULL; // and whose name is NULL
94 </pre>
95 <p>(Cribbed from the published version of
97 Effective C++ CD</a>, reproduced here with permission.)
98 </p>
99 <p>If you aren't using g++ (why?), but you do have a compiler which
100 supports member function templates, then you can use this definition
101 of NULL (be sure to #undef any existing versions). It only helps if
102 you actually use NULL in function calls, though; if you make a call of
104 where you started.
105 </p>
107 permission to
108 print this stuff, it prompted him to run this code through current
109 compilers to see what the state of the art is with respect to member
110 template functions. He posted
112 article to Usenet</a> after discovering that the code above is not
113 valid! Even though it has no data members, it still needs a
114 user-defined constructor (which means that the class needs a type name
115 after all). The ctor can have an empty body; it just needs to be
116 there. (Stupid requirement? We think so too, and this will probably
117 be changed in the language itself.)
118 </p>
121 </p>
123 <hr />
126 <p>This header mainly defines traits classes to give access to various
127 implementation defined-aspects of the fundamental types. The
128 traits classes -- fourteen in total -- are all specilizations of the
130 <a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/structstd_1_1numeric__limits.html">here</a>
131 and defined as follows:
132 </p>
133 <pre>
135 static const bool is_specialized;
136 static T max() throw();
137 static T min() throw();
139 static const int digits;
140 static const int digits10;
141 static const bool is_signed;
142 static const bool is_integer;
143 static const bool is_exact;
144 static const int radix;
145 static T epsilon() throw();
146 static T round_error() throw();
148 static const int min_exponent;
149 static const int min_exponent10;
150 static const int max_exponent;
151 static const int max_exponent10;
153 static const bool has_infinity;
154 static const bool has_quiet_NaN;
155 static const bool has_signaling_NaN;
156 static const float_denorm_style has_denorm;
157 static const bool has_denorm_loss;
158 static T infinity() throw();
159 static T quiet_NaN() throw();
160 static T denorm_min() throw();
162 static const bool is_iec559;
163 static const bool is_bounded;
164 static const bool is_modulo;
166 static const bool traps;
167 static const bool tinyness_before;
168 static const float_round_style round_style;
169 };</pre>
172 </p>
174 <hr />
178 the destructors of automatic nor static objects, so if you're depending
179 on those to do cleanup, it isn't going to happen. (The functions
181 can forget about that possibility, too.)
182 </p>
184 you look closer. Basically, three points to remember are:
185 </p>
186 <ol>
187 <li>Static objects are destroyed in reverse order of their creation.
188 </li>
190 reverse order of registration, once per registration call.
191 (This isn't actually new.)
192 </li>
194 given this pseudocode:
195 <pre>
196 extern "C or C++" void f1 (void);
197 extern "C or C++" void f2 (void);
199 static Thing obj1;
200 atexit(f1);
201 static Thing obj2;
202 atexit(f2);
203 </pre>
205 obj2 will be destroyed, then f1 will be called, and finally obj1
206 will be destroyed. If f1 or f2 allow an exception to propagate
207 out of them, Bad Things happen.
208 </li>
209 </ol>
211 functions, and the compiler/library might already be using some of
212 those slots. If you think you may run out, we recommend using
213 the xatexit/xexit combination from libiberty, which has no such limit.
214 </p>
217 </p>
219 <hr />
221 <p>If you are having difficulty with uncaught exceptions and want a
222 little bit of help debugging the causes of the core dumps, you can
223 make use of a GNU extension in GCC 3.1 and later:
224 </p>
225 <pre>
228 int main()
229 {
230 std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
231 ...
233 }</pre>
235 of the current exception, attempts to demangle it, and prints it to
238 </p>
239 <p>Any replacement termination function is required to kill the program
240 without returning; this one calls abort.
241 </p>
242 <p>For example:
243 </p>
244 <pre>
248 struct argument_error : public std::runtime_error
249 {
250 argument_error(const std::string& s): std::runtime_error(s) { }
251 };
253 int main(int argc)
254 {
255 std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
258 else
259 throw argc;
260 }
261 </pre>
263 </p>
264 <pre>
265 % ./a.out
266 terminate called after throwing a `int'
267 Aborted
268 % ./a.out f f f f f f f f f f f
269 terminate called after throwing an instance of `argument_error'
270 what(): argc is greater than 5!
271 Aborted
272 %</pre>
273 <p>The 'Aborted' line comes from the call to abort(), of course.
274 </p>
276 termination handler; nothing need be done to use it. To go back to
279 and call
280 </p>
281 <pre>
282 std::set_terminate(std::abort);</pre>
285 </p>
287 <p>
288 This function will attempt to write to stderr. If your application
289 closes stderr or redirects it to an inappropriate location,
291 unspecified manner.
292 </p>
294 <hr />
299 </p>
300 <ul>
302 this is what most people are used to using</li>
308 </ul>
309 <p>They are distinguished by the parameters that you pass to them, like
311 are distinguished the same way, but none of them are allowed to throw
312 an exception under any circumstances anyhow. (They match up for
313 completeness' sake.)
314 </p>
316 NULL pointer! Nothing happens, by definition. That is not the
317 same thing as deleting a pointer twice.
318 </p>
320 allocate the memory requested, it tosses an instance of a
322 from it). You can change this by writing your own function (called a
324 </p>
325 <pre>
326 typedef void (*PFV)(void);
328 static char* safety;
329 static PFV old_handler;
331 void my_new_handler ()
332 {
333 delete[] safety;
334 popup_window ("Dude, you are running low on heap memory. You
335 should, like, close some windows, or something.
336 The next time you run out, we're gonna burn!");
337 set_new_handler (old_handler);
338 return;
339 }
341 int main ()
342 {
343 safety = new char[500000];
344 old_handler = set_new_handler (&my_new_handler);
345 ...
346 }
347 </pre>
349 class defined in Chapter 19.
350 </p>
353 </p>
355 <hr />
359 of the cross-vendor C++ ABI which we use. One of the exposed
360 functions is the one which we use for demangling in programs like
362 </p>
363 <p>(The function itself might use different demanglers, but that's the
364 whole point of abstract interfaces. If we change the implementation,
365 you won't notice.)
366 </p>
367 <p>Probably the only times you'll be interested in demangling at runtime
369 you're handling the runtime-support exception classes. For example:
370 </p>
371 <pre>
376 struct empty { };
379 struct bar { };
382 int main()
383 {
384 int status;
385 char *realname;
388 // instead of the user
389 std::bad_exception e;
391 std::cout << e.what() << "\t=> " << realname << "\t: " << status << '\n';
392 free(realname);
395 // typeid
397 const std::type_info &ti = typeid(u);
400 std::cout << ti.name() << "\t=> " << realname << "\t: " << status << '\n';
401 free(realname);
403 return 0;
404 }</pre>
406 </p>
407 <pre>
410 <p>The demangler interface is described in the source documentation
411 linked to above. It is actually written in C, so you don't need to
412 be writing C++ in order to demangle C++. (That also means we have to
413 use crummy memory management facilities, so don't forget to free()
414 the returned char array.)
415 </p>
418 </p>
421 <!-- ####################################################### -->
423 <hr />
426 Comments and suggestions are welcome, and may be sent to
428 </em></p>
431 </body>
432 </html>