Problems with the ArrayT class.

• We are working on Common Memory Pitfalls starting on page 229.
• You should read chapter 7 up to smart pointers.
• Indexing out of bounds.
  • This is a basic array problem.
  • But if size/capacity are wrong we have a problem.
• Memory Leaks
  • With the basic program, we will a memory leak.
  • To correct this, we need to have a destructor.
• Destructors are discussed in chapter 8, page 276.
  • These are called when an object goes out of lifetime.
  • They are your chance to clean up memory.
  • What should we do when the class goes out of lifetime?
• Double free
  • If we haven't, lets add a pass an array object by value function.
  • Notice this has a double free?
  • Why?
• Dangling Pointer
  • Another problem with the pass by value is a dangling pointer.
  • This is when a pointer is pointing to invalid memory.
  • How can this happen with a pass by value?
• Multiple pointers to the same memory.
  • A third problem is that we have two pointers to the same memory, but we don't think that is the case.
  • This is also from the pass by value parameter.
  • How does this happen?
• Deep copy vs shallow copy.
  • Normal pass by value performs a shallow copy.
    • Every field in the structure is copied to the parameter.
    • This means, the pointer is copied, not the underlying memory.
  • The compiler has no knowledge of the underlying data structure
  • Thus is can not do a deep copy.
  • But there is a mechanism for this, the copy constructor.
• The copy constructor
  • no return type
  • Object Name
  • Single parameter, a reference to an object of this type.
  • ArrayT(const ArrayT & src);
  • The reference is important, why?
• The copy constructor is called
  • During a pass by value.
  • When an object is returned by value
  • When an object is constructed using an object of the same type.
• Finally, we can have problems with the = operator.
  • This is the assignment operator.
  • By default it makes a shallow copy of the right hand side.
  • We need to overload this to make a deep copy when dynamic memory is involved.
  • To implement the overloaded assignment operator we will need this
    • This is an internal member
    • It is a pointer to the structure.
  • We use this to avoid a = a

  • ArrayT & operator = (const ArrayT & src) {
        if (this != &src) {
           // code to do a deep copy of dynamic memory
           // also do a shallow copy  
        }
        return *this
    }
            

• When writing a class that contains dynamic memory always include
  • A destructor
  • A copy constructor
  • An overloaded assignment operator.