How to reuse the dynamically allocated memory inside a function in main()?

[vineesh vs]

#include<stdio.h>
#include<stdlib.h>
 
 
 
 
int **transpose(int **x,int m,int n);
 
 
 
main()
{
  int nrows=2,ncolumns=2,i,j,k=0;
 
 
  //memory allocation for array x
  int **array;
  array = malloc(nrows * sizeof(int *));
  if(array == NULL)
    {
      printf("out of memory\n");
      return 0;
    }
 
 
  for(i = 0; i < nrows; i++)
    {
      array[i] = malloc(ncolumns * sizeof(int));
      if(array[i] == NULL)
    {
      printf("out of memory\n");
      return 0;
    }
    }
 
 
 
 
 
 
  //define x
  printf("x=\n");
  for(i=0;i<2;i++)
    {
printf("\n");      
  for(j=0;j<2;j++)        
    {
      k=k+5;
      array[i][j]=i+j+k;
      printf("%d\t",array[i][j]);
    } 
    }
  printf("\n");
 
 
 
 
 
 
  //memory allocation for x_transpose, (storing the transpose returned by function)
 
  int **x_transpose;
  x_transpose = malloc(nrows * sizeof(int *));
  if(x_transpose == NULL)
    {
      printf("out of memory\n");
      return 0;
    }
 
 
  for(i = 0; i < nrows; i++)
    {
      x_transpose[i] = malloc(ncolumns * sizeof(int));
      if(x_transpose[i] == NULL)
    {
      printf("out of memory\n");
      return 0;
    }
    }
 
 
 
 
 
 
 
  //call function
  x_transpose= transpose(array,nrows,ncolumns);
 
 
 
 
 
 
  //display transpose
  printf("x_transpose=\n");
  for(i=0;i<2;i++)
    {
printf("\n");      
  for(j=0;j<2;j++)        
    {
      printf("%d\t",x_transpose[i][j]);
    }
    }
}
 
 
 
 
 
 
 
 
 
//function_transpose
 
int **transpose(int **x,int m,int n)
{
  int nrows=n,ncolumns=m,i,j;
 
  //memory allocation for y,to store transpose
  int **y;
  y = malloc(nrows * sizeof(int *));
  if(y == NULL)
    {
      printf("out of memory\n");
      return 0;
    }
  for(i = 0; i < nrows; i++)
    {
      y[i] = malloc(ncolumns * sizeof(int));
      if(y[i] == NULL)
    {
      printf("out of memory\n");
      return 0;
    }      
    }
 
 
 
 
 
  for(i=0;i<m;i++)
    for(j=0;j<n;j++)
      {
    y[i][j]=x[j][i];
      }
  return y;
}
 

i allocated memory for storing y(transpose of matrix) inside the function. also i allocated memory(for x_transpose) for storing the same result in main program. can reuse the same memory in main also???

[weaknessforcats]

YOu have what appears to be serious memory issues.

This code:

 int **x_transpose; 
  x_transpose = malloc(nrows * sizeof(int *)); 
 etc...  
 
   //call function 
  x_transpose= transpose(array,nrows,ncolumns); 

It appears the address allocation of x_transpose is overwritten by the transpose function.

Also your allocated memory is never freed.

As far reuse goes any allocated memory is your to use as often as you wish until you free it. The real trick is keeping all of the addresses of your allocations in scope. If you lose an address you lose the allocation.

[vineesh vs]

1.thanks.. that helps. so i need not have to allocate memory for x_transpose, and just need to declare as

int **x_transpose

????
2. i am afraid i did not get the sentence,
"As far reuse goes any allocated memory is your to use as often as you wish until you free it. The real trick is keeping all of the addresses of your allocations in scope. If you lose an address you lose the allocation. "
3. where should i free the memory allocated inside a function? is it at the end of the function or at the end of main program???

[weaknessforcats]

Answer to question 1:
Yes. That's correct. The only additional thing I would do is set the pointer to 0. By convention any non-zero pointer is assumed to contain a valid address. 0 is widely recognized as "no address inside", that is, a null pointer.

Answer to question 2:
When you use malloc, you receve a pointer to the memory allocated by malloc. If you lose that pointer you lose your allocation:

void Func()
{
 
   int* ptr = malloc(sizeof(int) * 20);
}

When Func() returns ptr is deleted. The allocated memory is still there and it is still yours. Only now there is no way to access it. That allocation will stay there until the program completes and it permanently reduces the amount of free memory available. Hence this is called a memory leak--the free memory just drains away.

You must either return ptr or you must free the allocation while still inside Func().

Answer to question 3:
You free memory when your program no longer will access it. That may be inside the function or it may be in
main(). One of the problems in freeing allocated memory is knowing when to do it. There are some techniques that would take too much room to go into here. I suggest additional reading or Googleing.

[vineesh vs]

ok. got it.. thanks..