C++ array initialization by reference through function - c++

Question

I'm working on a project that requires many dynamically sized 2D arrays that need to be accessible across functions.
The code I'm working on uses pointers like double** dynArray for this.
R = ...; // ROWS of the matrix, unknown prior to runtime
C = ...; // COLUMNS of the matrix, unknown prior to runtime
double** dynArray;
After checking the existing code I found that the arrays are currently always being initialized like this:
double** dynArray = new double*[R];
for(int r=0; r<R; r++){dynArray[r] = new double[C];}
In order to improve the readability I would like to write a method to do the above.
Here's what I came up with to allocate
void initialize2D(double*** data, int R, int C){
(*dynArray) = new double*[R];
for(int r=0; r<R; r++){
(*dynArray)[r] = new double[C];
for(int c=0; c<C; c++){
(*dynArray)[r][c] = 0;
}
}
}
and free memory respectively:
void free2D(double*** data, int R, int C){
for(int r=0; r<R; r++){
delete[] (*data)[r];
}
delete *data;
}
I intended to use these methods like this:
R = ...; // ROWS of the matrix, unknown prior to runtime
C = ...; // COLUMNS of the matrix, unknown prior to runtime
double** dynArray;
initialize2D(&dynArray, R, C);
/* do stuff*/
free2D(&dynArray,R,C);
After implementing these functions I ran Valgrind and found that this qualifies as a
definitely lost, sometimes
possibly lost.
What is the problem, and what would be the proper way to initialize through a function by reference?

Answer 1

Write the functions the following way
double ** initialize2D( int R, int C )
{
double **dynArray = new double *[R];
for ( int r = 0; r < R; r++ )
{
dynArray[r] = new double[C]();
}
return dynArray;
}
void free2D( double **data, int R )
{
for ( int r = 0; r < R; r++ ) delete [] data[r];
delete [] data;
}
And call the functions the following way
double** dynArray = initialize2D( R, C );
/* do stuff*/
free2D( dynArray, R );
dynArray = nullptr;
Take into account that you could use standard container std::vector<std::vector<double>> instead of dynamically allocate the arrays yourself.

Answer 2

Assuming it is necessary to pass the pointer to the function to initialise it ...
void initialize2D(double*** data, int R, int C)
{
*data = new double*[R];
for(int r=0; r<R; r++)
{
(*data)[r] = new double[C];
for(int c=0; c<C; c++)
{
(*data)[r][c] = 0;
}
}
}
void free2D( double ***data, int R )
{
for ( int r = 0; r < R; r++ ) delete [] (*data)[r];
delete [] (*data);
*data = nullptr;
}
Personally, however, I wouldn't directly use dynamic memory allocation at all. Instead I'd do;
#include <vector>
// and in your code
void some_function()
{
std::vector<std::vector<double> > dynArray(R, std::vector<double>(C));
// use dynArray as if it is a 2D array. All elements dynArray[i][j]
// will be initialised to zero, for i = 0 to R-1 and j = 0 to C-1
dynArray[3][4] = 42; // assuming R > 3 and C > 4
// ALL memory allocated for dynArray will be released here automatically as it passes out of scope
}
The advantage of this is that the standard vector class will happily manage all memory allocation and deallocation for you.
It is easy enough to pass such vectors around by reference.

Answer 3

An alltogether better way to code what you have above is:
#include <vector>
std::vector<std::vector<double>> initialise2D(int r, int c)
{
std::vector<std::vector<double>> result(r);
for(int i=0; i<r; ++i) result[i].reserve(c);
return result;
}
void free2D(std::vector<std::vector<double>> &v)
{
v.clear();
}
you can then
auto dynArray = initialise3D(20, 30);
You should also note that you do not actually need free2D any longer. I kept it here only for you to see how much easier things have became.
You will also note that you can use vector in the same way as you used array. That is why there was no problem for me to write result[i] using square brackets, as if it were an array.