Unexpected array results in c++

Question

This is a difficult issue but I'm not sure where to turn. To sum it up from the start, I'm having trouble with arrays in c++. To head off your inevitable response, I have to use arrays, I can't use vectors. The reason being that I will eventually be interfacing this with CUDA which can't accept vectors.

Anyway, I have written my own class to handle 2D arrays and all the stuff that goes with that behind the scenes. The header file is reproduced at the bottom of this question. I use this class to define a 6 x 10 array. I then loop over many items, primarily using the add method of my class. At some point in this complicated loop, the size of my array switches from 6 x 10 to 0 x 1074266112. I have tried to debug my code and figure out what the issue is but for the life of me I cannot find the issue.

I've printed out all the values at the moment the array size changes, and none of them are out of the norm and I'm never trying to index the array outside of the 6x10 size. In fact, it never even happens at the same point of the loop, it just seems to happen randomly for each run. The only constant I can find between each issue is that the new array size is always exactly 0 x 1074266112.

Sorry I can't provide a minimum working example, but this issue only crops up in my large program and I can't reproduce it in a smaller program. I was at least hoping anyone could see if I'm doing anything wrong with my Matrix program below and possibly suggest a method of debugging.

EDIT: If I change this to use a vector rather than an array, the issue goes away. I.e., if I change the relevant parts to vector<double> data and upon instantiating, data = *(vector<double>(x * y)), the issue mentioned above is no longer a problem. However I have no idea what could be the problem with making this an array.

#include <vector>
#include <iostream>
#ifndef MATRIX_H
#define MATRIX_H

using std::vector; using std::cout; using std::endl;

class Matrix {
    //Define the private variables associated with any instance of this class.
    double * data;      //The 1D pointer which points to the array
    int w, h;           //The width and height of the 2D array that the 1D data array represents
public:

    Matrix(){}
    Matrix(int x, int y){ setSize(x,y); }

    void setSize(int x, int y){ w = x; h = y; data = new double[x * y]; setAll(0); }

    //Two methods to get the height and width of the effective 2D array
    int getWidth(){ return w; }
    int getHeight(){ return h; }

    //Several methods used to set and get the values of elements within the array as well as extracting
    //rows and columns as vectors.
    void set(int x, int y, double value){ data[y*w + x] = value; }
    void setAll(double value);
    double get(int x, int y){ return data[y*w + x]; }
    vector<double> getCol(int x);
    vector<double> getRow(int y);

    //Several methods to adjust the current value by the input
    void increment(int x, int y){ data[y*w + w] += 1; }
    void add(int x, int y, double value){ data[y*w + x] += value; }
    void subtract(int x, int y, double value){ data[y*w + x] -= value; }
    void multiply(int x, int y, double value){ data[y*w + x] *= value; }
    void divide(int x, int y, double value){ data[y*w + x] /= value; }

};

void Matrix::setAll(double value){
    for (int i = 0; i < w*h; i++){
        data[i] = value;
    }
}

vector<double> Matrix::getCol(int x){
    vector<double> column(h);
    for (int i = 0; i < h; i++){ column[i] = data[i*w + x]; }
    return column;
}

vector<double> Matrix::getRow(int y){
    vector<double> row(w);
    for (int i = 0; i < w; i++){ row[i] = data[y*w + i];    }
    return row;
}

#endif  /* MATRIX_H */

Answer 1

Your increment method is wrong; it depends only on y when from context it looks like you intended to also use x in the array index calculation. If you're calling this increment somewhere in your program, you're probably writing to memory off in la-la land somewhere. I don't know if that's the only cause of your issue, but anyway it will corrupt your heap in probably unhelpful ways.