PART 8 Q32: Does `delete ptr' delete the ptr or the pointed-to-data? A: The pointed-to-data. When you read `delete p', say to yourself `delete the thing pointed to by p'. One could argue that the keyword is misleading, but the same abuse of English occurs when `free'ing the memory pointed to by a ptr in C: free(ptr); /* why not `free_the_stuff_pointed_to_by(p)' ?? */ Q33: Can I free() ptrs alloc'd with `new' or `delete' ptrs alloc'd w/ malloc()? A: No. You should not mix C and C++ heap management. Q34: Why should I use `new' instead of trustworthy old malloc()? A: malloc() doesn't call constructors, and free() doesn't call destructors. Besides, malloc() isn't type safe, since it returns a `void*' rather than a ptr of the right type (ANSI-C punches a hole in its typing system to make it possible to use malloc() without pointer casting the return value, but C++ closes that hole). Besides, `new' is an operator that can be overridden by a class, while `malloc' is not overridable on a per-class basis (ie: even if the class doesn't have a constructor, allocating via malloc might do inappropriate things if the freestore operations have been overridden). Q35: Why doesn't C++ have a `realloc()' along with `new' and `delete'? A: Because realloc() does *bitwise* copies (when it has to copy), which will tear most C++ objects to shreds. C++ objects know how to copy themselves. They use their own copy constructor or assignment operator (depending on whether we're copying into a previously unused space [copy-ctor] or a previous object [assignment op]). Moral: never use realloc() on objects of a class. Let the class copy its own objects. Q36: How do I allocate / unallocate an array of things? A: Use new and delete: Thing* p = new Thing; //... delete  p; //older compilers require you to use `delete  p' Any time you allocate an array of things (ie: any time you use the `[...]' in the `new' expression) you *!*MUST*!* use the `' in the `delete' statement. The fact that there is no syntactic difference between a ptr to a thing and a ptr to an array of things is an artifact we inherited from C. Q37: What if I forget the `' when `delete'ing array allocated via `new X[n]'? A: Life as we know it suddenly comes to a catastrophic end. It is the programmer's --not the compiler's-- responsibility to get the connection between new and delete correct. If you get it wrong, neither a compile-time nor a run-time error message will be generated by the compiler. Depending on the implementation, the results *may* be harmless if the class whose objects are being `delete'd has no destructor, but this is implementation dependent. If the class *does* have a destructor, only the first object in the array (the one at `ptr') will be destructed properly; the rest will simply be abandoned. If the destructor releases memory, this will be a memory leak; if it closes files or unlocks semaphores or other environmental actions, system integrity may be fractured. Q38: What's the best way to create a `#define macro' for `NULL' in C++? A: The best way is: don't do it. The most portable way to compare against the nil ptr is to compare against `0'. Some programmers use a #define to set NULL to `0', but that can conflict with the way the standard libraries #define NULL. There is no portable way to define a `const' ptr called `NULL' that can be compared against any arbitrary ptr -- the literal `0' is acceptable for this however.