use a returned array on the fly, how to release its memory?

Question

I just learned how to correctly return an array, Return a 2d array from a function, but how can I release the memory of a returned array used on the fly if I want to do something like the following

dMAT=matmul(DIM,transpose(DIM,EState),dMAT);

where both Matmul and Transpose are user-defined functions returning a 2D array. Since now Matmul and Transpose are used on the fly, I don't have a handler towards the returned arrays and thus cannot release the memory in the said method.

EDIT:

An example of Matmul and Transpose are given below,

 double **transpose(int & dim, double ** mat){

   double **mat1 = new double *[dim];
   for(int i=0; i<dim; i++) {
     mat1[i] = new double [dim];
     for(int j=0; j<dim; j++) mat1[i][j] = mat[j][i];
   }

   return mat1;

 }


 double **matmul(int & dim, double ** mat1, double **mat2){

   double **mat3 = new double *[dim];
   for(int i=0; i<dim; i++) {
     mat3[i] = new double [dim];
     for(int j=0; j<dim; j++) {
        mat3[i][j]=0.0;
        for(int k=0; k<dim; k++) mat3[i][j]+=mat1[i][k]*mat2[k][j];
     }
   }

   return mat3;

 }

In C++, you generally don't (use standard containers or smart pointers). — crashmstr, May 22 '17 at 13:15
What type of array ? C style array ? Dynamically allocated array ? ? ``std::vector`` or ``std::array`` ? You should add the prototype of your functions. — nefas, May 22 '17 at 13:15
Have you learned the difference between memory allocation via `malloc` (as one might get when working with C APIs from C++) and via `new`? — infixed, May 22 '17 at 13:17
@n.m. I am not used to template, but try to use the most familiar way to finish work first. — bsmile, May 22 '17 at 13:22

score 1 · Accepted Answer · edited Jul 16 '19 at 15:01

Use std::vector; it will save you a lot of trouble.

In your code, there is no way to release memory without having a temporary variable on which you can call delete. std::vector (and other RAII wrappers) will help you by managing the lifetime of the resources (here the memory).

Using C-style coding (manual memory management with new and delete) is not the way to write code in C++: it's hard and you will write buggy code. Learn good C++ coding style (RAII, ...) from the beginning.

Ivan Sheihets · Answer 2 · 2017-05-22T13:35:27.117

1

you can make something like that:

double *f(const int& size) 
{
   double *arr = new double[size];
   for (int i=0;i<size;i++)
       arr[i] = i;

   return arr;
}

int main()
{
  double *a = f(10);
  delete []a;
}

it is not for 2d array but I think you understand main idea

edited May 22 '17 at 13:35

answered May 22 '17 at 13:32

Ivan Sheihets

802
8
17

I need something to be on the fly. – bsmile May 22 '17 at 13:33
you can use it on fly. try to use stl container, like vector or array – Ivan Sheihets May 22 '17 at 13:37

score 1 · Answer 3 · answered May 22 '17 at 13:39

You use a class, which encapsulates the allocation and freeing.

Something like

class matrix {
    std::vector<std::vector<double>> mat;
public:
    matrix(int dim) : mat(dim, std::vector(std::vector(dim))) {}
    // Other members, e.g. transpose, operator+ and operator*
};

Or, rather than writing it yourself, you use a library like Eigen that has written it for you.

eerorika · Answer 4 · 2017-05-22T14:01:49.110

I just learned how to correctly return an array

Since it is not possible to return an array by value, it will be useful to be precise: You've learned how to return a pointer that holds the address of an object that is an element of an array.

how can I release the memory of a returned array

You allocated the memory by calling new[]. Therefore you must release the memory by calling delete[]. delete[] is used by passing the address returned by new[] as an argument.

Since you wish to use the pointer not only for releasing the memory, but also to pass it to another function matmul (or sometimes matmul?), you will want to store the pointer in a variable so that you can copy it:

auto arr = transpose(DIM,EState);
dMAT = matmul(DIM,arr,dMAT);
// now, you can release the memory pointed by arr

However, don't shoot yourself in the foot by storing dynamic memory in bare pointers. Use RAII containers such as std::vector instead.

use a returned array on the fly, how to release its memory?

4 Answers4