proper memory allocation for a 2D array in a class in C++

Question

I am writing a C++ class that uses some fixed arrays, as well as some dynamically allocated arrays. I was wondering if anybody can guide me for the proper way to allocate memory for the dynamic arrays , probably in the constructor/deconstructor, and also if I need to explicitly call them to make sure I don't get a seg fault. Here is a simplified version of the related part of my code:

class Network {

    public:
    int n_nodes;
    int user_index[MAX_USERS]; //a fixed array
    int adjacency_matrix[][MAX_ITEMS];

    //Network(int n_node, int** adjacency); //I would rather to set the element s in a function other than the constructor
    Initializer(int n_node, int** adjacency);
    ~Netowrk();
    }

So here are my specific question for this class:

1 - Can I have the 2D array adjacency_matrix[][] with undecided number of rows and columns until it's set by the user in the initializer function?

2 - where should I delete the 2D array? should I write it in the deconstructor? Should I call the deconstructor explicitly? Is there anything else I need to destroy in the deconstructor?

Answer 1

1 - Can I have the 2D array adjacency_matrix[][] with undecided number of rows and columns until it's set by the user in the initializer function?

Yes. The best way to do this, however, is not to use arrays at all. Instead, use std::vector, which manages the memory for you. There are two ways that you can do this. If you actually want to be able to use the [row][column] syntax to access elements, you'll need to use two dimensions of std::vectors:

std::vector<std::vector<int> > adjacency_matrix;

Once you know the dimensions, you can populate it:

adjacency_matrix.assign(rows, std::vector<int>(columns));

It is often easier to use a single-dimensional array (or a std::vector<int>) containing all of the elements and use row * row_count + column to access the element at index (row, column). This way, there are fewer dynamic allocations. You can wrap up the logic of accessing elements into a couple of helper functions.

2 - where should I delete the 2D array? should I write it in the deconstructor?

You don't have to delete anything if you use a std::vector. It cleans itself up.

Should I call the [destructor] explicitly?

No.

Is there anything else I need to destroy in the [destructor]?

Ideally, no. If you use the Standard Library containers, like std::vector and smart pointers, you shouldn't have to clean anything up. You should avoid trying to manage resources on your own in C++: there are library facilities to do this tedious task for you and you should take advantage of them.

Answer 2

1 - Can I have the 2D array adjacency_matrix[][] with undecided number of rows and columns until it's set by the user in the initializer function?

Yes you can. For example:

    int* adjacency_matrix_;
    int* getAdjacency(int i, int j) 
    {
        if (!adjacency_matrix_)
            return 0;
        else 
            return adjacency_matrix_ + i*n_nodes + j;
    }
    Network()
        : n_nodes(0),
        adjacency_matrix_(0)
    {}
    void Initializer(int n_node, int** adjacency)
    {
        adjacency_matrix_ = new int[n_nodes * n_nodes];
        // Copy over data.
    }

As to whether you should, that depends on whether you have a reason for not using std::vector<>.

2 - where should I delete the 2D array? should I write it in the deconstructor? Should I call the deconstructor explicitly? Is there anything else I need to destroy in the deconstructor?

Yes, definitely free in the destructor using array operator delete:

~Network()
    {
        delete [] adjacency_matrix_;
    }

No, your destructor will be called whenever the Network object itself goes out of scope. It is (very) rarely necessary to make an explicit destructor call.

No, all a destructor needs to explicitly release is whatever your explicitly acquire.

Answer 3

You may like the example matrix class I wrote in an answer to another question

The question itself was about good C++ design practices, but the chosen example was a multi-dimensional array.

Answer 4

There are several ways to do this.

The easiest way is to use vectors, and if you don't like to manage your own memory, this is perfect for you. However, because I like to manage my own memory, and I have found this method to be slow and cumbersome at times, I have learned of other ways.

The fastest way is to allocated a one dimensional array and treat it as you would a two dimensional array. Here is an example:

int *array = new int[width*height];

int get_array(int column, int row)
{
     return array[row*width + column];
}

delete [] array;

This can be generalized to the nth-dimension:

int *array = new int[w1*w2*...*wn];

int get_array(int i1, int i2, ..., int in)
{
     return array[in*(w1*w2*...*w(n-1)) + i(n-1)*(w1*w2*...*w(n-2)) + ... + i2*w1 + i1];
}

delete [] array;

If you want to be able to have different widths for each row, then you can make an array of pointers. This solution is slow to initialize and clean up, but flexible, tunable, and has relatively fast execution time. It can also be extremely dangerous if you make a mistake though.

int **array = new int*[height];

for (int i = 0; i < height; i++)
     array[i] = new int[width(i)];

at which point, to access it, all you have to do is the customary

array[i][j]

however, to free this array you have to do it row by row

for (int i = 0; i < height; i++)
     delete [] array[i];

delete [] array;

This can also generalize to the nth dimension.

int **....*array = new int**...*[w1];

for (int i1 = 0; i1 < w1; i1++)
{
     array[i1] = new int**..*[w2];
     for (int i2 = 0; i2 < w2; i2++)
     {
          array[i1][i2] = new int**.*[w3];
          ...
          for (int in = 0; in < wn; in++)
               array[i1][i2]...[in] = new int[wn];
     }
}

for (int i1 = 0; i1 < w1; i1++)
{
     for (int i2 = 0; i2 < w2; i2++)
     {
          ...
          for (int in = 0; in < wn; in++)
               delete [] array[i1][i2]...[in];
          ...
          delete [] array[i1][i2];
     }
     delete [] array[i1];
}

delete [] array;

This kind of setup tends to wreak havoc on memory. Just a two dimensional array of these would result in width+1 separate arrays to be malloc-ed. It would be faster to just malloc one big array and figure out the indices yourself.