Dynamic Memory

• Most of today is from the first part of chapter 14.
• Look at the code quickly.
  • ArrayT.h
  • ArrayT.C
  • ArrayTest.C
• Discuss static memory in this class.
  • When is memory allocated?
  • How much memory is allocated?

    • size_t i;

    • ArrayT ary; 

    • int y;
      foo(y);
      void Foo(int x){ 

    • int y;
      foo(y);
      ...
      void Foo(int & x){ 

    • void FillArray(ArrayT & ary){

    • void PrintArray(ArrayT ary){

• Where is memory allocated?
  • This is a generalization, but worth understanding.
  • We will not worry about main, it is handled different
    • As are variables with the keyword static
    • And global constants and variables.
  • Assume we have a function

    • void foo(int x) {
          char y;
          // assume no more variable declarations.
      }
      

    • We know at compile time that foo needs space to store
      • an integer parameter x
      • a character variable y
    • We don't know how many times foo might be called.
    • To handle this, these variables will be stored on the runtime stack or just stack
• Computer Memory.
  • Memory is just a giant array of binary values.
  • We tend to think of it in terms of words
  • We tend to address it by bytes
  • The operating system organizes the memory.
  • It is divided into segments which is why you get segmentation violations.
  • Two special places in memory are the
    • stack or runtime stack
    • heap or free store.
• The stack
  • This is usually in high memory (largest addresses)
  • 
  • It grows down.
  • As functions are called, their variables are placed on the stack.
  • So a call to foo
  • 
  • As functions are called, their static memory is added to the stack.
  • As functions return, their static memory is removed from the stack.
  • Think about variable lifetime in relationship to the stack
    • There are ways to extended this, but the concepts are very closely related.
  • You will learn much more of this in Architecture (312)
• The heap
  • The heap is a pool of memory locations reserved for and allocation and deallocation of dynamic data.
  • The heap is below the stack.
  • It grows up.
  • 
  • Programmers can allocate memory from the heap
    • Or request that the OS provide them with memory on the heap
    • This is done with the c++ command new
    • Or with the c command malloc
  • This memory is available until the programmer deallocates it.
    • Or return the memory to the heap for future use.
    • This is done with the c++ command delete
    • Or the c command free
  • We will exclusively use new and delete.
    • If I say malloc or free, please correct me.
• Pointers
  • This is section 10.7 and chapter 14
  • A pointer type is a simple data type consisting of an unbounded set of values each of which addresses or otherwise indicates the location of a variable of a given type. Among the operations defined on pointer variables are assignment and testing for equality.
  • That is the book's definition.
  • A pointer is a variable that points at a different location in memory.
  • Think
  • 
  • Or better yet
  • 
  • Declaration
    • datatype * identifier;
    • datatype * identifier, * identifier, * identifier;
    • The star (*) goes with the variable.
  • use
    • Assignment stores a pointer or address in memory
    • *identifier follows the pointer.
    • On both the left and right hand side.

    • int * xPtr;
      
      // memory allocation needs to happen here
      ...
      *xPtr = 7;
      cout << *x; 

    • We will see this soon.
• new
  • Takes a data type
  • And returns a pointer to memory allocated on the heap of the given size.
  • new int
    • allocates an integer sized memory location on the heap.
    • And returns a pointer to that memory.
• Putting it together.

  • int * xPtr;
    
    xPtr = new int;
    *xPtr = 7;
    

  • 
  • We will frequently draw this as
  • 
  • Or even
  • 
• This seems a bit useless right now, but we will build on it.