A Funkaoshi Production

Testing Memory Allocation Failure

   15 December 2004, evening time

When programming in C a programmer usually uses the malloc function to request memory on the heap. In C++ one can use malloc, but generally the proper thing to do is use new, and for arrays new[]. The new operator, when successful, returns a block of memory big enough for the object or array one wishes to store. Unfortunately, sometimes new and malloc will fail to find any memory.

Now, in C the proper thing to do is check that the memory was allocated before an attempt to use it. malloc returns 0 when it fails to find enough free memory. The common idiom in C then is to test if the value of the pointer pointing to the memory requested is NULL (0) after a call to malloc.

1. ...
2. int* my_int_ptr = malloc( sizeof(int) );
3. if ( 0 == my_int_ptr ) {
4. // handle error
5. }
6. ...
7. Download this code: /static/code/9.txt

I was vaguely aware that in C++ things were different, but didn’t concern myself with learning exactly how different till today. If a computer fails to allocate memory after a call to new or malloc, chances are the computer is on the verge of crashing. As such, for most programs a reasonable course of action when a new or malloc fails is to simply terminate. However, there are many applications where this is not a reasonable thing to do. When faced with writing such an application, it helps to know what will happen when new fails.

A normal call to new throws a bad_alloc exception. If this is not caught, it will get transformed into a std::terminate() call. std::terminate() by default calls abort(), which exits the running program and does not run destructors for static objects. This is quite different from malloc. The following program will crash (on my local machine the program outputs ‘Aborted’):

1. #include <iostream>
2. int main() {
3. const int n = 0x7FFFFFFF;
4. for (;;) {
5. char* memory = new char[n];
6. if ( 0 == memory ) {
7. std::cerr << "Operator new returns a NULL";
8. } else {
9. memory[0] = 'A';
10. memory[n-1] = 'B';
11. std::cout << "A-OK";
12. }
13. }
14. return 0;
15. }
16. Download this code: /static/code/6.txt

Testing for NULL will accomplish nothing, the program will still crash. To have new behave like malloc when it fails one must call the overloaded version of new, new(nothrow). Doing so will result in new not throwing an exception and returning NULL if it fails. This program will print “Operator new returns NULL” forever:

1. #include <iostream>
2. int main() {
3. const int n = 0x7FFFFFFF;
4. for (;;) {
5. CHAR* memory = new(std::nothrow) char[n];
6. if ( 0 == memory ) {
7. std::cerr << "Operator new returns a NULL";
8. } else {
9. memory[0] = 'A';
10. memory[n-1] = 'B';
11. std::cout << "A-OK";
12. }
13. }
14. return 0;
15. }
16.  
17. Download this code: /static/code/7.txt

By default new uses the advanced erorr handling capabilities of C++. As such, using new(nothrow) is really not a good solution when one needs to write a robust program. One should make it a point to catch the bad_alloc exception a call to new may throw, and handle it appropriately. This program will print “New throws a bad_alloc exception” forever:

1. #include <iostream>
2. int main() {
3. const int n = 0x7FFFFFFF;
4. for (;;) {
5. try {
6. char* memory = new char[n];
7. memory[0] = 'A';
8. memory[n-1] = 'B';
9. std::cout << "A-OK";
10. }
11. catch (std::bad_alloc)
12. {
13. std::cerr << "New throws a bad_alloc exception";
14. }
15. }
16. return 0;
17. }
18. Download this code: /static/code/8.txt

And that is more then you probably wanted to know about new.

Code | Computer Science