A dynamic Array

We continue with chapter 14.
We would like to build a list class that can grow without bound.
The idea is that we will use the array based implementation.
- But we will use a dynamic array.
A dynamic array will be
- Allocated with a fixed size.
- When it becomes full, we will
  - Allocate a new array
  - Copy the data from the old array over
  - Delete the old array.
We need to make some changes in the header file
- ```
//int data[MAX_ITEMS];
int capacity;
int * data=nullptr;
        
```
- capacity will be used to track how big the array is.
- Size will still track how many elements of the array are used.

We will allocate memory in the constructor

data = new int[10];
capacity = 10;

IsFull just returns false.

The only other change is Insert

void ListT::Insert(int key){
    int * tmp = nullptr;
    int i;

    if (size == capacity) {

        // allocate a new array of double the size
        capacity *= 2;
        tmp = new int[capacity];

        // copy the data from the original array to the new array
        for(i = 0; i < size; i++) {
           tmp[i] = data[i];
        }

        // delete the old array.
        delete [] data;

        // change the pointer to point at the new item
        data = tmp;
    }

    // just add it to the array.
    data[size] = key;
    size++;
}

I did need to change listTest.cpp
- I referred to MAX_ITEMS
- This is bad, it was implementation information.
- And now it is gone.
- I just changed all references to be 20.

Valgrind is a tool that helps us check for memory problems.

valgrind ./listTest

==19867==
==19867== HEAP SUMMARY:
==19867==     in use at exit: 400 bytes in 2 blocks
==19867==   total heap usage: 8 allocs, 6 frees, 74,448 bytes allocated
==19867==
==19867== LEAK SUMMARY:
==19867==    definitely lost: 400 bytes in 2 blocks
==19867==    indirectly lost: 0 bytes in 0 blocks
==19867==      possibly lost: 0 bytes in 0 blocks
==19867==    still reachable: 0 bytes in 0 blocks
==19867==         suppressed: 0 bytes in 0 blocks
==19867== Rerun with --leak-check=full to see details of leaked memory
==19867==
==19867== For lists of detected and suppressed errors, rerun with: -s
==19867== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Notice that we definitely had a memory leak.
Why?
- We didn't delete the arrays at the end.
this is a memory leak.
- Memory that is not deallocated but nothing points to it.

Deleting memory with a class destructor.
- This is the main purpose of the destructor.
- The destructor is called when an instance of the class goes out of lifetime and scope.
- It can be used in our case to clean things up.

My Destructor

// in the header file
~ListT();

// in the implementation file.
ListT::~ListT() {
    delete [] data;
    data = nullptr;
    capacity = 0;
}

Compile and every thing is fine.
Run and Boom, a crash.
- This is because of our destructor.
- But the destructor is fine.
- The real cause is TellAboutList
- It is a pass by value.
  - Pass by value is evil.
  - Always pass by reference, or constant reference.
  - In this case we can't pass by constant reference.
- The problem is due to a shallow copy.
By default c++ performs a shallow copy
- It just copies the values of the variables.
- This is fine for most normal variables.
- But with dynamic memory it only copies pointers.
The problem is
- When we make the copy, two pointers are pointing to the memory
- The parameter and the argument.
- But when we exit the destructor of the parameter is called.
- And now the argument points to deleted memory.
- Or it is a dangling pointer.
  - A pointer pointing to memory that has been deallocated.
- And it leads to calling delete on the same memory twice.
  - This is definitely a cause of a crash.
The solution is a copy constructor.
- The copy constructor is a function that is called when the compiler needs to make a copy of an object.
- It takes a single parameter, the object to copy.
- this MUST be passed by constant reference.
- Otherwise there is an infinite recursion.
- ```
// in ListT.h
ListT(const ListT & other);

// in ListT.cpp
ListT::ListT(const ListT & other) {
    size_t i;

    capacity = other.capacity;
    size = other.size;
    current = other.current;
    data = new int[capacity];

    for(i=0; i < size; i++) {
        data[i] = other.data[i];
    }

    return;
} 
```
- Notice, inside of a class, I have access to the private members of other instances of the class.
- This is by design.
Run it now, no problem.
When building a copy constructor
- Make sure you copy ALL of the data fields.
- Make sure it is a pass by constant reference.
One final part needed, and overloaded assignment operator.
- By default the compiler will create an == operator for us.
- But unfortunately this is a shallow copy as well.
- There are two more things we need to do
  - Make sure you are not copying on top of yourself.
  - Get rid of any existing memory.
    - This was not a problem for the copy constructor as we were building a new verion.
    - And there was no memory allocated.
  - Return a reference to the item.
    - A strange thing in c++ is you can do
    - a = b = c = d = e;
  - Both of these require the use of the this pointer.
- My overloaded assignment operator
  - ```
  // in the header file
  ListT & operator =(const ListT & other);
  
  // in the implementation file
  ListT & ListT::operator = (const ListT & other) {
     size_t i;
  
     if (this != & other) {
         delete [] data;
  
         capacity = other.capacity;
         size = other.size;
         current = other.current;
         data = new int[capacity];
  
         for(i=0; i< size; i++) {
             data[i] = other.data[i];
         }
     }
  
     return *this;
  }
               
```
When you create a class with dynamic memory
- Create a destructor to prevent memory leaks.
- Create a copy constructor to prevent dangling pointers and memory leaks.
- Create an overloaded assignment operator to prevent dangling pointers and memory leaks.