arrays, removeFirst() not working? - c++

Question

I have created a method that should remove the first element of an array, however when I run my code, the debugger flips out and I'm not sure why.
This is my removeFirst() method:
Loan & ListOfLoans :: removeFirst(){
index = 0;
//determine if the container needs to be shrunk
if((numberOfElements < capacity/4) && (capacity >= 4)){ // shrink container when array is 1/4 full
cout<<"shrinking array! \n";
Loan ** temp = elements;
elements = new Loan * [numberOfElements/2];
//copy temp array to elements
for(int i = 0; i<numberOfElements; i++){
temp[i] = elements[i];
numberOfElements = numberOfElements/2;
delete [] temp;
}
}
numberOfElements--;
return **elements;
}
And my header file for good measure:
#include <iostream>
#include "loan.h"
using namespace std;
class ListOfLoans {
public:
ListOfLoans(int initial_size=4);
~ListOfLoans(void);
void add(Loan & aLoan);
Loan & first() ;
Loan & removeFirst();
// answer the first element from the list and remove it from the list
// if the resulting list is more than three quarters empty release some memory
Loan & removeLast();
// answer the last element from the list and remove it from the list
// if the resulting list is more than three quarters empty release some memory
Loan & next();
int size();
private:
Loan ** elements; //actuall stuff in the array m_pnData;
int numberOfElements; //number of elements in the list stize of the array? m_nLength
int capacity; //size of the available array memory
int index; //used to help with the iteration
};

Answer 1

Try moving delete [] temp; under the for loop.
It looks like one issue may be that delete [] temp; is being called repeatedly within the for loop.
The first iteration through the loop, the memory associated with temp will freed. Subsequent iterations through the loop will access the freed memory.
There may be other issues. It would be very helpful to see the output from the debugger.

Answer 2

There are many issues with this code. Here is an annotated copy.
// Return by reference cannot be used if you are removing the element.
// This looks like a Java-ism.
Loan & ListOfLoans :: removeFirst(){
// unused variable
index = 0;
if((numberOfElements < capacity/4) && (capacity >= 4)){
cout<<"shrinking array! \n";
Loan ** temp = elements;
// you are allocating an array of size numberOfElements/2...
elements = new Loan * [numberOfElements/2];
// then accessing elements which are way past its end.
for(int i = 0; i<numberOfElements; i++){
temp[i] = elements[i];
// you are halving the array size in every iteration
numberOfElements = numberOfElements/2;
// you are deleting temp in every iteration,
// causing double-frees
delete [] temp;
}
}
// if the array does not need to be shrunk,
// you are actually removing the last element.
// the removed element is not freed and is leaking.
numberOfElements--;
// you are returning the first element,
// which is not removed.
return **elements;
}
I would strongly recommend to replace ListOfLoans with an STL container, such as std::deque. If you can't do this, here is a minimal fixed version.
Loan ListOfLoans::removeFirst() {
Loan to_return;
if (numberOfElements == 0) {
return to_return; // return default value, there is nothing to remove
}
if ((numberOfElements < capacity/4) && (capacity >= 4)) {
Loan **old = elements;
capacity = capacity / 2;
elements = new Loan*[capacity];
for (int i=0; i < numberOfElements - 1; ++i) {
elements[i] = old[i+1];
}
to_return = *old[0];
delete old[0];
delete[] old;
} else {
to_return = *elements[0];
delete elements[0];
for (int i=0; i < numberOfElements - 1; ++i) {
elements[i] = elements[i+1];
}
}
--numberOfElements;
return to_return;
}