C / C++ and Dynamic memory allocation

Program memory: Heap vs Stack

Dynamic memory is allocated on the "heap". The heap is the region of computer memory which is managed by the programmer using pointers to access the memory.

Heap memory details:

can be accessed globally
your limit is the physical memory limit of your system (real and virtual)
user managed memory. Programmer must allocate and free memory.
memory access is via pointer and thus requires dereferencing to access, requiring extra operations and time
memory can become defragmented as memory is allocated and freed
memory can be resized (eg using realloc())

The "stack" is the region of memory which stores declared variables in main() and all called functions. When a function returns, the memory space for the declared variables is released ("popped"). The stack is FILO (first in - lst out) and unwinds variables in memory as functions return.

the "stack" grows and shrinks as functions push and pop local variables
the "stack" is managed by the OS
the default "stack" size is limited by the OS. A stack overflow occurs when this limit is exceeded (eg endless function recursion).

Example of behavior of objects declared on the heap vs stack:

01#include <iostream>
02using namespace std;
03 
04class AAA
05{
06public:
07    AAA();
08    AAA(int);
09    ~AAA();
10private:
11    int ii;
12};
13 
14AAA::AAA()
15: ii(1)
16{
17    cout << "Constructor called. Value of ii=" << ii << endl;
18}
19 
20AAA::AAA(int _ii)
21: ii(_ii)
22{
23    cout << "Constructor called. Value of ii=" << ii << endl;
24}
25 
26AAA::~AAA()
27{
28    cout << "Destructor called. Value of ii=" << ii << endl;
29}
30 
31main()
32{
33    cout << "Start of program" << endl;
34    AAA a1;               // Declared on the stack.
35    AAA a2(2);            // Declared on the stack.
36    AAA *a3 = new AAA(3); // Dynamically allocated memory on the heap
37    AAA *a4 = new AAA(4); // Dynamically allocated memory on the heap
38    delete a3;            // If not called, then destructor not called
39    cout << "End of program" << endl;
40}

Compile: g++ test.cpp
Run: ./a.out

Start of program
Constructor called. Value of ii=1
Constructor called. Value of ii=2
Constructor called. Value of ii=3
Constructor called. Value of ii=4
Destructor called. Value of ii=3
End of program
Destructor called. Value of ii=2
Destructor called. Value of ii=1

Note:

Stack: The objects a1 and a2 are declared on the stack. The constructors are called automatically where they are declared. The destructors are called automatically when they go out of scope (as defined by the last "}").
Heap: Objects allocated dynamically on the heap with "new" automatically have their constructors called. Note that the destructor for a3 is called when the memory is freed with "delete". Delete is not called for a4 and thus the destructor is not called.

C malloc and free vs C++ new and delete:

C malloc() and free() do not call constructors or destructors. C++ new and delete operators are "class aware" and will call class constructors when a class is allocated with new and a destructor when delete is called. [example]

Mixing malloc with delete or new with free is undefined. In addition, C++ new and delete operators were introduced with the C++ practice of allocating memory in constructors and deallocating the same memory with a destructor.

new/delete advantages:

new/delete invokes constructor/destructor. Malloc/free will not.
new does not need typcasting. Malloc requires typcasting the returned pointer.
new/delete operators can be overloaded, malloc/free can not.
new does not require you to explicitly calculate the quantity of memory required. (Unlike malloc)

C dynamic memory allocation:

Use "malloc", "calloc" and "free": File: MallocTest.cpp

01#include <stdio.h>
02#include <string.h>
03#include <stdlib.h>
04#include <error.h>
05#include <errno.h>
06 
07typedef struct
08{
09   int ii;
10   double dd;
11} SSS;
12 
13int main()
14{
15   int kk, jj;
16 
17   char *str1 = (char *) "This is a text string";
18   char *str2 = (char *) malloc(strlen(str1));
19 
20   errno = 0;
21   SSS *s1 = (SSS *)calloc(4, sizeof(SSS));  // Memory for 4 of struct SSS
22   if(s1 == NULL)
23   {
24      if(errno == ENOMEM) printf("Error ENOMEM: Insufficient memory available\n");
25   }
26 
27   strcpy(str2,str1); /* Make a copy of the string */
28 
29   for(kk=0; kk < 5; kk++)
30   {
31      s1[kk].ii=kk;
32   }
33 
34   for(jj=0; jj < 5; jj++)
35   {
36      printf("Value stored: %d\n",s1[jj].ii);
37   }
38 
39   free(s1);
40   free(str2);
41}

Compile: gcc -o MallocTest MallocTest.cpp

Run: MallocTest

Value stored: 0
Value stored: 1
Value stored: 2
Value stored: 3
Value stored: 4

Manual pages:

malloc: a memory allocator
calloc: a memory allocator
realloc: memory reallocator
free: frees the memory space pointed to by ptr
errno: obtains error number of last error
perror: obtains error number of last error

Note that calloc() zeros memory while malloc() does not.

C++ dynamic memory allocation:

Use "new" and "delete": File: AllocNewTest.cpp

01#include <iostream>
02 
03class CCC
04{
05public:
06   CCC(){};
07   CCC(int);
08   CCC(int, double);
09   int ii;
10   double dd;
11};
12 
13CCC::CCC(int _ii)
14    : ii(_ii)
15{
16};
17 
18CCC::CCC(int _ii, double _dd)
19    : ii(_ii), dd(_dd)
20{
21};
22    
23using namespace std;
24 
25main()
26{
27   CCC *cc1 = new CCC(4, 5.5);   // Pointer. Contructor called.
28   CCC *cc2 = new CCC[5];        // Pointer to an array of objects.
29   CCC &cc3 = *new CCC;          // Reference
30   CCC **c4 = new CCC * [5];     // Array of pointers to pointers
31 
32   cc1->ii   = 5;
33   cc2[3].ii = 6;
34   cc3.ii    = 7;
35   c4[0]     = new CCC(8);
36   c4[1]     = new CCC(9);
37 
38   cout << cc1->ii   << endl;
39   cout << cc2[3].ii << endl;
40   cout << cc3.ii    << endl;
41   cout << c4[0]->ii << endl;
42   cout << c4[1]->ii << endl;
43 
44   delete cc1;
45   delete [] cc2;
46   delete & cc3;
47 
48   delete [] c4[0];   // First delete pointer content
49   delete [] c4[1];
50   delete [] c4;      // then delete array of pointers
51}

Note the difference between:

new CCC(3) creates memory for a single object who's integer member is set to 3.
new CCC[3] creates memory for three objects of type CCC and no variables are set.

Compile: g++ -o AllocNewTest AllocNewTest.cpp

Run: ./a.out

C function returning a pointer vs C++ function returning a copy:

C function returning a pointer:

01#include <stdio.h>
02#include <stdlib.h>
03 
04char *fnConvert(int _ii)
05{
06   char *str = (char *) malloc(10);  /* Return 10 character string */
07   if(str == NULL)
08   {
09      fprintf(stderr,"Error: Memory allocation failed.\n");
10      perror("malloc");
11   }
12   sprintf(str, "%d", _ii);
13   return str;
14}
15 
16main()
17{
18   char *s1=fnConvert( 34567 );
19 
20   printf("%s\n", s1);
21 
22   free(s1);
23}

C++ function returning a copy:

01#include <iostream>
02#include <sstream>
03#include <string>
04 
05using namespace std;
06 
07string fnConvert(int _ii)
08{
09   ostringstream ost;
10   ost << _ii;
11   return ost.str();
12}
13 
14main()
15{
16    cout << fnConvert( 34567 ) << endl;
17}

Note: The STL string class copy constructor is employed to return a copy (return by value). Yes the variable "ost" is out of scope once we leave the function, but the copy of its contents is valid. Do not "return ost.str().c_str()" as this pointer is out of scope once the procesing leaves the function and the data lost.

C++ dynamic memory allocation exception handling:

Use exception handling:

01#include <iostream>
02 
03using namespace std;
04 
05main()
06{
07   int ii;
08   double *ptr[5000000];
09 
10   try
11   {
12      for( ii=0; ii < 5000000; ii++)
13      {
14         ptr[ii] = new double[5000000];
15      }
16   }
17 
18   catch ( bad_alloc &memmoryAllocationException )
19   {
20      cout << "Error on loop number: " << ii << endl;
21      cout << "Memory allocation exception occurred: "
22           << memmoryAllocationException.what() 
23           << endl;
24   }
25   catch(...)
26   }
27      cout << "Unrecognized exception" << endl;
28   {
29}

Compile: g++ -o AllocNewTest AllocNewTest.cpp

Run:

Observer system limits: ulimit -a
Set system limits: ulimit -m 100
Run with fewer privileges: nice -n 19 AllocNewTest

C++ Virtual Destructors:

Using polymorphism to delete dynamically allocated objects by their base class pointer: Declare base class destructor virtual so that the delete operator can be applied to the base class pointer. The derived class destructor is called first, before the base class destructor.

01#include <iostream>
02using namespace std;
03 
04class Base
05{
06public:
07   Base(){};
08   virtual ~Base(){ cout << "Base class destructor called" << endl; }
09};
10 
11class Derived : public Base
12{
13public:
14   Derived(){};
15   ~Derived(){ cout << "Derived class destructor called" << endl; }
16};
17 
18 
19main()
20{
21   Base *ptr = new Derived();
22   delete ptr;
23}

Resutls:

Derived class destructor called
Base class destructor called

Note:

If the delete operator is applied to the base class and the destructor is NOT virtual, then this will cause a memory leak as only a portion of the memory is freed.
Base class destructor is not pure virtual (set =0) or there would be no base class implementation of the destructor..
Class contructors can NOT be virtual.

Notes and Tutorials:

Books:

	C++ How to Program by Harvey M. Deitel, Paul J. Deitel ISBN #0131857576, Prentice Hall Fifth edition. The first edition of this book (and Professor Sheely at UTA) taught me to program C++. It is complete and covers all the nuances of the C++ language. It also has good code examples. Good for both learning and reference.
	Exceptional C++: 47 Engineering Puzzles, Programming Problems and Solutions by Herb Sutter ISBN #0201615622, Addison-Wesley Professional Advanced C++ features and STL.
	More Exceptional C++ by Herb Sutter ISBN #020170434X, Addison-Wesley Professional
	Effective C++: 50 Specific Ways to Improve Your Programs and Design (2nd Edition) by Scott Meyers ISBN #0201924889, Addison-Wesley Professional
	More Effective C++: 35 New Ways to improve your Programs and Designs by Scott Meyers ISBN #020163371X, Addison-Wesley Professional