Variable values are changing

Question

I have a template class that I am testing:

class SparseMat {
private: 
   FHvector<FHlist<MatNode<Object>>> matrix;
   int numOfRows, numOfCols;
   const Object defaultValue;
public:
   SparseMat(int r, int c, const Object& defaultVal);
   const Object & get(int r, int c) const;
   bool set(int r, int c, const Object& x);
};

template <class Object>
SparseMat<Object>::SparseMat(int r, int c, const Object& defaultVal) : defaultValue(defaultVal) {
   numOfRows = r;
   numOfCols = c;

   matrix.resize(numOfRows);

   for (int counter = 0; counter < numOfRows; counter++) {
      FHlist<MatNode<Object>> currentRow;
      matrix.push_back(currentRow);
   }
}

template <class Object>
bool SparseMat<Object>::set(int r, int c, const Object& x) {
   if (r >= numOfRows || r < 0 || c < 0 || c >= numOfCols) {
      return false;
   }
   if (r == 9 && c == 9) {
      cout << x << endl;
   }
   if (r == 9 && c == 9) {
      cout << x << endl;
   }
   for (FHlist<MatNode<Object>>::iterator iter = matrix[r].begin(); iter != matrix[r].end(); ++iter) {
      if ((*iter).getCol() == c) {
         if (x == defaultValue) {
            matrix[r].erase(iter);
            return true;
         }
         else {
            (*iter).data = x;
            return true;
         }
      }
   } 
   matrix[r].push_back(MatNode<Object>(c, x));
   return true;
}

template <class Object>
const Object & SparseMat<Object>::get(int r, int c) const {
   if (r >= numOfRows || r < 0 || c < 0 || c >= numOfCols) {
      throw OutOfBoundsException();
   }
   FHlist<MatNode<Object>> wantedRow = matrix[r];
   for (FHlist<MatNode<Object>>::iterator iter = wantedRow.begin(); iter != wantedRow.end(); ++iter) {
      if ((*iter).getCol() == c) {
         return (*iter).getData();
      }
   }
   return NULL;
}

MatNode is as follows:

template <class Object>
class MatNode
{
protected:
   int col;

public:
   Object data;
   MatNode(int cl = 0, Object dt = Object()) : col(cl), data(dt) { }
   int getCol() const { return col; }
   const Object & getData() const {return data; }
};

The immensely strange thing is my two outputs print two different things. The first prints 21, as expected. The second prints out some random float, which is definitely not expected as I have changed nothing with x between the two outputs.

#include <iostream>
using namespace std;
#include "FHsparseMat.h"

#define MAT_SIZE 100000
typedef SparseMat<float> SpMat;

int main()
{

   SpMat mat(MAT_SIZE, MAT_SIZE, 0); 
   mat.set(3, 9, 21);
   cout << mat.get(3, 9) << endl;
   mat.set(9, 9, 21);
   cout << mat.get(9, 9) << endl;
   mat.set(9, 9, mat.get(3,9)); 
   cout << mat.get(9, 9) << endl;
}

Here is my tester. If I replace mat.get(3,9) with the hard coded value of 21, the issue disappears, if that helps.

Answer 1

get() has a return type of const Object &.

As a result, the final line of the function

return 0; // source code says NULL but preprocessor replaces that with 0

is returning a dangling reference to a temporary Object implicitly constructed with the value 0.

Using that dangling reference will, of course, cause undefined behavior.

It's not completely clear why that line is reached, but the logic that erases an item if you write the same value to the same location certainly seems suspicious. IMO you should only remove an item when the value written is zero.

Answer 2

The issue is that Object MatNode::getData() const is not returning a reference, and you are returning a reference in const Object & SparseMat<Object>::get(int r, int c) const. Change it to:

Object SparseMat<Object>::get(int r, int c) const.