How can we find MEMORY SIZE from given memory pointer ?

Question

void func( int *p)
{
  // Add code to print MEMORY SIZE which is pointed by pointer P.
}
int main()
{
  int *p = (int *) malloc (10);
  func(p);
}

How can we find MEMORY SIZE from memory pointer P in func() ?

Answer 1

There is no legal way to do this in C (or even C++ I believe). Yes, somehow free knows how much was malloced but it does so in a way that is not visible or accessible to the programmer. To you, the programmer, it might as well have done it by magic!

If you do decide to try and decode what malloc and free does then it will lead you down the road to proprietary compiler implementations. Be warned that even on the same OS, different compilers (or even different versions of the same compiler, or even the same compiler but using a third party malloc implementation (yes such things exist)) are allowed to do it differently.

Answer 2

If you program for Microsoft Windows, you can use the Windows API Heap* functions instead of the functions provided by your programming language (C in your case). You allocate memory with HeapAlloc, reallocate with HeapReAlloc, free memory with HeapFree, and, finally, obtain the size of a previously allocated block with the HeapSize function.

Another option, of course, is to write wrapper functions for malloc and friends, that store an index of allocated blocks and their sizes. This way you can work with your own functions for allocating, reallocating, freeing, and measuring memory blocks. Writing such wrapper functions should be trivial (although I do not know C, so I cannot do it for you...).

Answer 3

When developing applications, to know the memory size allocated to a pointer, we actually pay attention at the moment we allocate memory for it, which in your case is:

int *p = (int *) malloc(10);

and then we store this information somewhere if we need to use it in the future. Something like this:

void func(int *p, size_t size)
{
  printf("Memory address 0x%x has %d bytes allocated for it!\n", p, size);
}

int main()
{
  int my_bytes = 10;
  int *p = malloc(my_bytes);
  func(p, my_bytes);

  return 0;
}

Answer 4

Many years ago, I programmed on a UNIX-like system that had a msize stdlib function that would return pretty much what you want. Unfortunately, it never became part of any standard.

msize called on a pointer returned from malloc or realloc would return the actual amount of memory the system had allocated for the user program at that address (which might be more than was requested, if it got rounded up for alignment reasons or whatever.)

Answer 5

Firstly, as all the others have said, there is no portable way to know the size in allocation unless you keep this information.

All that matters is the implementation of the standard C library. Most libraries only keep the size of memory allocated to a pointer, which is usually larger than the size your program requests. Letting the library keep the requested size is a bad idea because this costs extra memory and at times we do not care about the requested size.

Strictly speaking, recording the requested size is NOT a feature of a compiler. It seems to be sometimes because a compiler may reimplement part of the standard library and override the system default. However, I would not use a library recording requested size because it is likely to have bigger memory footprint due to the reason I said above.