Implementing a List Based Queue

• You might want to read parts of chapter 7 and 9 in your book.
  • Read 163-182 to review the basics of pointers.
  • Read 192-197 for a summary of common pointer errors.
  • Read 231-242 for a review of pointers in classes.
• We will not discuss smart pointers, and move constructors or assignment operators at this point.
  • We will discuss these later.
• I want to implement a queue as a list
• 
• I will need to allocate/deallocate memory as it is needed.
• This means pointers.
• A note on smart pointers.
  • You will generally see notes that say we should not use raw pointers.
  • But I feel we should get these worked out.
  • The others are MUCH easier to understand once you understand raw pointers.
• Remember
  • Dynamic memory is allocated at run time, not compile time.
  • It is allocated with either new or new []
    • This depends on if you are allocating a single instance or an array.
    • The array method is so that the destructors of ALL elements are called when the memory is freed.
    • Memory is free with either delete or delete []
  • For every new there should be a corresponding delete
  • Pointers are declared type * identifier
  • Address of static items are accessed with & identifier
  • Pointers can be followed (dereferenced) by
    • *identifier to get to an entire thing.
    • identifier->member to the member of a structure or class.
  • NULL, 0, and especially nullptr are all values to set "empty" pointers to.
    • You should always set a pointer to a valid address or nullpter when it is declared.
  • If memory allocation fails, you program will crash.
    • You can change this behavior
    • But you probably don't want to right now.
• On 168->174 he discusses the relationship between arrays and pointers.
  • I feel we discussed this last semester.
  • Give it a read.
• He discusses garbage collection
  • This is what languages like Python and Java do.
  • They have ways of finding if memory is still in use.
  • Occasionally they "sweep" the system and return unused memory to the heap.
• On 192, he begins the discussion of common memory pitfalls.
• Memory Leaks.
  • A pointer is pointing at allocated memory.
  • It is assigned new memory without freeing the old memory.
  • Consider this code

    FooT * a;
    
    a = new  FooT;
    // no delete follows
    ...
    
    a = new FooT;
              

• Double deleting
  • Memory is deleted twice.
  • Frequently occurs when two things point to the same memroy.

  • 
    void Fun1(FooT * param)  {
         FooT * b;
    
         b = param;
         ...
         delete b;
         return;
    }
    
    int main() {
        FooT a = new FooT;
    
        Fun1(a);
        delete a;
    
        return 0;
    } 

• A shallow copy is a copy of pointers only
  • This will result in a single copy of the data with two pointers pointing to it.
  • This is usually bad (but not always).
• A deep copy will allocate new memory and copy the values over.
  • This will result in a new copy of the data at a new location.
• When using dynamic memory in a class
  • You must include a destructor which deallocates the memory.
  • You must include a copy constructor.
    • This takes a reference to another instance of the class.
    • It must perform a deep copy of the dynamic memory.
    • It must perform a shallow copy of other memory.
  • You must include an overloaded assignment operator.
    • This takes a reference to another instance of the class.
    • It should check to see that it is not making a copy of it's self.
    • This frees any dynamically allocated memory.
    • Makes a deep copy of dynamic memory
    • It makes a shallow copy of other memory.
    • It returns a reference to the object.

    • FooT & operator = (FooT & src) {
          if (this != &src)
             // delete current memory
             // copy others
          }
          return *this;
      }