Determining Size of Memory Block Referenced by a Pointer

MS-DOS                 | WINDOWS   | OS/2            | WINDOWS NT

The information in this article applies to:

• Microsoft C for MS-DOS, versions 5.0, 5.1, 6.0, 6.0a, and 6.0ax
• Microsoft C for OS/2, versions 5.1, 6.0, and 6.0a
• Microsoft C/C++ for MS-DOS, versions 7.0
• Microsoft Visual C++ for Windows, versions 1.0 and 1.5
• Microsoft Visual C++, 32-bit Edition, versions 1.0 and 2.0

SUMMARY

In Microsoft C, there is no C run-time library function that explicitly returns the amount of memory that has been allocated to a pointer by malloc(). However, it is possible to retrieve this information indirectly through the Microsoft C run-time library function _heapwalk(). The _heapwalk() function returns a heap information structure of the following form:

   struct _heapinfo {
       int far * _pentry;
       size_t _size;
       int _useflag;
   } _HEAPINFO;

MORE INFORMATION

Sample Code

/* Compile options needed: none
*/

#include <stddef.h>
#include <malloc.h>

   struct _heapinfo info; /* Heap info structure */
   int   heap_status;     /* Heap status */
   size_t  ret_val;       /* msize() return value */

   info._pentry = NULL;   /* Initialize heap info structure */

   do {
      heap_status = _heapwalk(&info); /* Step through heap until */
   } while ((pointer != info._pentry) /* desired entry is found  */
     && (heap_status == _HEAPOK));   /* or a heap error occurs. */

   if(heap_status == _HEAPOK)
      if(info._useflag != _FREEENTRY)
         ret_val = info._size;          /* No errors */
      else {
         ret_val = 0;                  /* Entry has been freed */
         *error = _FREEENTRY;
      }
   else {
      ret_val = 0;     /* A heap error occurred */
      *error = heap_status;
   }
   return(ret_val);

NOTE: The msize() function takes as a parameter a pointer pointing to the base memory that was allocated. For msize() to work correctly, this pointer MUST point to the base of the allocated block, and not anywhere within that block.

The msize() function returns the size of the allocated block or -1 if an error occurs. If -1 is returned, an error code is returned through the error parameter. The error parameter will be one of the following manifest constants:

   _FREENTRY      _HEAPEMPTY      _HEAPBADPTR
   _HEAPBADBEGIN  _HEAPBADNODE    _HEAPEND

Following is a sample program that uses the msize() function to find the amount of memory allocated to a pointer. This function is designed to work in any memory model:

Sample Program

#include <stdio.h>
#include <malloc.h>

void main (void)

   char * p;
   int    error;
   size_t size;

   p = (char *)malloc(sizeof(char) * 11);
   if(p == NULL) {
      printf("Memory allocation error\n");
      return;
   }

   size = msize(p,&error);
   if(size == 0)
      printf("An msize error has occurred\n");
   else
      printf("Size = %u\n", size);

NOTE: The malloc() function allocates 11 bytes of memory for use by the pointer p. Surprisingly, msize() returns 12 as the size of the allocated block. Actually, this is an expected result. Malloc() always allocates even-byte amounts as a result of PC architecture. Consequently, msize()'s return value is always an even amount.