Deallocating inheritance, C++

Question

ostream& operator<<(ostream& out, const hashmap& h)
{
const char *getSymbol = NULL;
h.hashTable->displayHeaders(out);
for ( int hashIndex = 0; hashIndex < maxSize; hashIndex++ )
{   
    getSymbol = h.hashTable[hashIndex].getSymbol();
    if ( getSymbol )    
    {
        out << h.hashTable[hashIndex];
    }
}   
return out;
}

Answer 1

If I read the code right as the formatting is somewhat off, the problem is most likely that your stock copy constructor does a shallow copy whereas the assignment operator for the same class makes a deep copy. From reading the rest of the code, I assume you meant to make a deep copy instead of just duplicating the m_name and m_symbol pointers.

I'd also strongly suggest that you use std::string instead of raw char pointers - doing that in the first place would have avoided the issues I describe above. It would've also allowed you to use the compiler generate copy constructor, assignment operator and destructor. Less code is good .

Answer 2

Something went wrong with the formatting when you posted your code, so I had to move it to an external editor to read.

The problem is not a memory leak - that would be memory that you failed to reclaim. This is quite the opposite issue. Here, you are trying to reclaim memory that was already freed.

I would bet anything that the failing delete call in the destructor is occuring on an object that was either copied or populated using either the copy constructor or the second overloaded assignment operator. You are performing a shallow copy in those places, resulting in two stock objects referencing exactly the same memory for their mname and msymbol members. Whichever one of the two (or more if you copied many times) is destroyed first will have no problems. Whichever one is destroyed second will fail.

I also make the following observation: your constructor carefully checks symbol and name to see if they actually reference any data. Only then do you proceed to use their values. If they are null, then you assign a value of null to the corresponding members. The first overloaded assignment operator, on the other hand, is copying an instance of stock that for all you know could have null mname or msymbol members. You should treat those values with the same care you did in the constructor and test them before using.

Answer 3

The problem is here:

stock& stock::operator=(stock const * const s)

Look at the logic of this operator and the other assignment operator you declared: you copy m_symbol and m_name differently!

You would be better off defining the assignment operator only once:

stock& stock::operator=(stock const * const s)
{
  return this->operator=(*s);
}

Or the other way around if you prefer, but remember that the implementation of this one is off.