The Dynamic Array.

• Changes to the ArrayT class.
  • Add a variable to hold the capacity of the array.
  • Change data to be a pointer.
  • Add a destructor, what should this do?
  • Add an overloaded assignment operator.
    • By default the assignment operator is a shallow copy.
    • This would eventually lead to a dangling pointer and a double delete.

    • ArrayT & operator =(const ArrayT & src) 

      • Why pass the source by constant reference?
    • First thing to do, delete the data, why?
      • The item we are copying to is a valid array
      • This means it is pointing to dynamic memory right now
      • If we do not delete this memory, we will have a memory leak.
    • Copy the data.
    • Did you know that

       a=b=c=d=e=7

      is a valid expression?
    • Return a pointer to the array
      • In c++ the reserved word this is a reference to the object.
      • We need to finish the assignment operator with

      •  return *this

  • Add a copy constructor
    • By default when we pass a class by value, a copy constructor is invoked.
      • This is the constructor that is responsible for building a copy of an existing object.
      • It is called when an instance of a class is passed by value.
    • You can also call it manually

      • ArrayT a;
        ...
        
        ArrayT b(a);  // create an instance of b the same as a using the copy constructor 

    • Prototype

      • ArrayT(const & src); 

      • Why the pass by constant reference?
    • What needs to happen in the copy constructor.
  • Capacity needs to be changed to return capacity, not MAX_SIZE
  • Append needs to be changed
    • If we attempt to append at capacity what should we do?
    • We should double the capacity.
    • There are good reasons to do this.
    • We could also just increase the size by a fixed amount.