Introduction to Dynamic Memory

• ALL memory we have dealt with so far has been static memory.
  • Memory is associated with variables.
  • And variables, even arrays, structures and classes have a known size when we declare them.
  • Thus all memory we have dealt with so far is static memory
  • Or the size is known at compile time.
  • This memory is allocated on the run time stack.
• We can, however, allocate memory when the program is running.
• This is called dynamic memory
  • This memory is allocated off of the heap.
  • 
• Dynamic memory can lead to problems.
  • It requires attention to detail or your program crashes in unexpected ways.
  • Some languages do not allow direct access.
• But to be a competent computer science student we feel you should know about it.
• Lets draw a few scenarios

• 
  struct AStructT {
      int age;
      string name;
  };
  
  class BookT {
      private:
         string title;
         string author;
         int pages;
  };
  
  int anInt;
  int intArray[4];
  AStructT person;
  BookT myBook;
      

• With dynamic data, we actually have two locations
  • The data
  • A handle, or pointer to the data.
• This requires a new data type for the pointer.
  • type * identifier
  • int * intPtr;
  • The * is with the identifier so to declare two of them.
  • int * ptr1, * ptr2;
• There is a default value, nullptr
  • This is to indicate the pointer is not pointing to anything.
  • int * intPtr = nullptr;
• In general, when you have a pointer, you always want it to point to
  • Legitimate memory
  • nullptr.
  • As soon as you declare a pointer, point it to nullptr.
  • If you delete the memory that a pointer is pointing to, point it to nullptr.
• Memory is allocated with the new command.
  • new DataType is for a single instance of the data type.
  • new DataType [int expression] is for an array.
  • Each return a DataType * .
• Memory is disposed of using delete
  • delete ptr for a single instance
  • delete [] ptr for the array version
  • Only delete allocated memory once.
• The golden rule
  • For every memory allocation (new) , you must perform a corresponding memory deallocation (delete).
  • If you don't this is a Memory Leak
• By the way, a memory leak is not the only problem
  • An inaccessible object occurs when memory on the heap has been allocated but has nothing pointing to it.
  • A dangling pointer occurs when a pointer points to memory that has been deallocated.
• Try the following

• int * a = nullptr, 
      * b = nullptr, 
      * c = nullptr;
  
  a = new int;
  
  b = a;
  
  c = new int;
  c = new int;
  
  delete a;
  a = nullptr;
  delete c;
  a = nullptr;