Making WordListT Dynamic

• We want to make the WordListT dynamic.
  • The first step is to go with a dynamic array.
• As we saw last notes, an array and a pointer are interchangeable to some extent.
• So we just change the array implementation.
  • Edit the header file.
    • WordT * data;
  • In the constructor set data to be nullptr.
  • AddWord requires the most changes.
    • We no longer have the out of memory case, so delete this
    • Always return true.
    • In the new else clause
      • Allocate a new array.
      • Copy the data from the old array to the new array.
      • Delete the old array
      • Point the pointer at the new array.
      • Add the word.

      • } else  {
                // make space for the new word
                newList = new WordT[wordCount+1];
                for (i = 0; i < wordCount; i++) {
                   newList[i] = data[i];
                }
        
                if (data != nullptr) {
                    delete [] data;
                }
                data = newList; 

    • I think that is all.
  • Make it run.
• Valgrind
  • Valgrind is a cool tool for dynamic code analysis.
  • In this case, it will be helpful to find memory leaks
    • Memory that has been allocated but not deallocated.
  • valgrind WordCount2
  • We are losing a lot of memory. <>pre> ==6930== HEAP SUMMARY: ==6930== in use at exit: 4,568 bytes in 1 blocks ==6930== total heap usage: 119 allocs, 118 frees, 346,544 bytes allocated ==6930== ==6930== LEAK SUMMARY: ==6930== definitely lost: 4,568 bytes in 1 blocks
• A destructor
  • Add ~WordListT() to the header.
  • Add the destructor to delete the memory on exit.

  • WordListT::~WordListT() {
        if (data != nullptr) {
            delete [] data;
        }
    } 

  • Try Valgrind again.
• An experiment
  • I passed the WordListT to PrintArray by reference.
  • Try removing this, pass it by value.

  •                youve   1
    Getting the user action
    Performing the user action
    corrupted size vs. prev_size while consolidating
    Aborted (core dumped)

  • What happened?
    • A pass by reference makes a copy of the pointer.
    • Draw this.
    • What happened when the function exited?
    • This is a dangling pointer error and resulted in a double free.
  • How do we fix this?
    • We need to add a new constructor, a copy constructor.
    • This is responsible for building a new instance from an existing instance.
      • As such, it is called when we pass by value.
    • It needs to
      • Duplicate dynamic memory.
      • Copy over all
    • It takes a copy of an instance of the class.
    • But one restriction
      • The instance of the class must be pass by reference.
      • Otherwise it would need to call the copy constructor to be invoked
      • Which would be an infinite recursion.
  • Building a copy constructor
    • WordListT(WordListT & other)
    • The implement the code.
      • We need to make a copy of the dynamic data
      • We did this in the AddItem function.
      • So let's add another function.
      • It takes an array and a size returns a pointer to a new array
        • No need to make this a member function.

      • WordT * CopyArray(WordT ary[], int size, bool increase) {
            WordT * rValue{nullptr};
            int i;
            int newSize = size;
        
            if (increase) {
                newSize++;
            }
        
            rValue = new WordT [newSize];
            for (i =0; i < size; i++) {
                rValue[i] = ary[i];
            }
        
            return rValue;
        } 

    • The copy constructor becomes

    • WordListT::WordListT(WordListT & other) {
          data = CopyArray(other.data, other.wordCount, false);
          wordCount = other.wordCount;
          current = other.current;
      } 

    • Important here: notice I copy both the dynamic and static data.
  • You don't need a copy constructor if you don't have dynamic data.
    • The compiler will write a copy constructor for you
    • This will do the "right thing" if there is no dynamic data.