views:

6120

answers:

13

I've allocated an "array" of mystruct of size n like this:

if (NULL == (p = calloc(sizeof(struct mystruct) * n,1))) {
 /* handle error */
}

Later on, I only have access to p, and no longer have n. Is there a way to determine the length of the array given just the pointer p?

I figure it must be possible, since free(p) does just that. I know malloc() keeps track of how much memory it has allocated, and that's why it knows the length; perhaps there is a way to query for this information? Something like...

int length = askMallocLibraryHowMuchMemoryWasAlloced(p) / sizeof(mystruct)

I know I should just rework the code so that I know n, but I'd rather not if possible. Any ideas?

+9  A: 

keep track of the array size yourself; free uses the malloc chain to free the block that was allocated, which does not necessarily have the same size as the array you requested

Steven A. Lowe
+1  A: 

I'm not aware of a way, but I would imagine it would deal with mucking around in malloc's internals which is generally a very, very bad idea.

Why is it that you can't store the size of memory you allocated?

EDIT: If you know that you should rework the code so you know n, well, do it. Yes it might be quick and easy to try to poll malloc but knowing n for sure would minimize confusion and strengthen the design.

Bob Somers
A: 

malloc will return a block of memory at least as big as you requested, but possibly bigger. So even if you could query the block size, this would not reliably give you your array size. So you'll just have to modify your code to keep track of it yourself.

David Arno
+1  A: 

One of the reasons that you can't ask the malloc library how big a block is, is that the allocator will usually round up the size of your request to meet some minimum granularity requirement (for example, 16 bytes). So if you ask for 5 bytes, you'll get a block of size 16 back. If you were to take 16 and divide by 5, you would get three elements when you really only allocated one. It would take extra space for the malloc library to keep track of how many bytes you asked for in the first place, so it's best for you to keep track of that yourself.

Greg Hewgill
Actually that's a perfect reason why you should be able to ask the malloc library how big a block is. It never made sense to me that the C language was designed without such a query function.
Windows programmer
I once worked on a system where the standard allocate function returned both the block and its actual size (>= requested size of course). Good for things like buffers and caches, where you can profitably use any excess space.
Steve Jessop
c-the-language is a convenient expression of assembly. The standard library is minimal as befits the tight constraints of the systems it originally ran on (and still does in embedded-land). If you want an allocator that provides lots of bells and whistles, use one.
dmckee
+3  A: 

Righto. I guess I'll suck it up and rework the code. Thanks.

Joel
+16  A: 

No, there is no way to get this information without depending strongly on the implementation details of malloc. In particular, malloc may allocate more bytes than you request (e.g. for efficiency in a particular memory architecture). It would be much better to redesign your code so that you keep track of n explicitly. The alternative is at least as much redesign and a much more dangerous approach (given that it's non-standard, abuses the semmantics of pointers, and will be a maintenance nightmare for those that come after you): store the length n at the malloc'd address, followed by the array. Allocation would then be

void *p = calloc(sizeof(struct mystruct) * n + sizeof(unsigned long int),1));
*((unsigned long int*)p) = n;

n is now stored at *((unsigned long int*)p) and the start of your array is now

void *arr = p+sizeof(unsigned long int);

Edit: Just to play devil's advocate...I know that these "solutions" all require redisgns, but let's play it out. Of course, the solution presented above is just a hacky implementation of a (well-packed) struct. You might as well define

typedef struct { 
  unsined int n;
  void *arr;
} arrInfo;

and pass around arrInfo's rather than raw pointers.

Now we're cooking. But as long as you're redesigning, why stop at here? What you really want is an abstract data type (ADT). Any text introductory text for an algorithms and data structures class would do it. An ADT defines the public interface of a data type but hides the implementation of that data type. Thus, publically an ADT for an array might look like

typedef void* arrayInfo;
(arrayInfo)newArrayInfo(unsignd int n, unsigned int itemSize);
(void)deleteArrayInfo(arrayInfo);
(unsigned int)arrayLength(arrayInfo);
(void*)arrayPtr(arrayInfo);
...

In other words, an ADT is a form of data and behavior encapsulation... in other words it's about as close as you can get to Object-oriented Programming using straight C. Unless you're stuck on a platform that doesn't have a C++ compiler, you might as well go whole hog and just use an STL stl::vector.

There, we've taken a simple question about C and ended up at C++. God help us all.

Barry Wark
@Joel - Ever think of how delete [] *p manages to call all the destructors in the array pointed to by p - well thats coz new does the same thing that bary suggested. new stores the no of items in the array in the beginning of the array and gives you the pointer past this 1st location.
@computinglife - not necessarily, an allocator could easily keep metadata in a different part of memory than the bits it's handing out, to prevent buffer overruns from corrupting internal data structures, or put the number a few bytes earlier.
ephemient
In fact, glibc's default allocator places the size immediately before the returned pointer, but uses the lower bits for metadata -- thus the number must be masked off to be accurate.
ephemient
+1  A: 

Just to confirm the previous answers: There is no way to know, just by studying a pointer, how much memory was allocated by a malloc which returned this pointer.

What if it worked?

One example of why this is not possible. Let's imagine the code with an hypothetic function called get_size(void *) which returns the memory allocated for a pointer:

typedef struct MyStructTag
{ /* etc. */ } MyStruct ;

void doSomething(MyStruct * p)
{
   /* well... extract the memory allocated? */
   size_t i = get_size(p) ;
   initializeMyStructArray(p, i) ;
}

void doSomethingElse()
{
   MyStruct * s = malloc(sizeof(MyStruct) * 10) ; /* Allocate 10 items */
   doSomething(s) ;
}

Why even if it worked, it would not work anyway?

But the problem of this approach is that, in C, you can play with pointer arithmetics. Let's rewrite doSomethingElse():

void doSomethingElse()
{
   MyStruct * s = malloc(sizeof(MyStruct) * 10) ; /* Allocate 10 items */
   MyStruct * s2 = s + 5 ; /* s2 points to the 5th item */
   doSomething(s2) ; /* Oops */
}

How get_size is supposed to work, as you sent the function a valid pointer, but not the one returned by malloc. And even if get_size went through all the trouble to find the size (i.e. in an inefficient way), it would return, in this case, a value that would be wrong in your context.

Conclusion

There are always ways to avoid this problem, and in C, you can always write your own allocator, but again, it is perhaps too much trouble when all you need is to remember how much memory was allocated.

paercebal
The fact that get_size must be passed a pointer to the start of an allocated block is no bar to having it. Just don't pass in an invalid value. free() has the same constraint, and that exists...
Steve Jessop
Of course, but free is usually used with this in mind, along the malloc that allocated the memory. get_size would be used everywhere, including where the user is not supposed to know how the memory was allocated altogether (on the stack, via a pool, etc.).
paercebal
A: 

May I recommend a terrible way to do it?

Allocate all your arrays as follows:

void *blockOfMem = malloc(sizeof(mystruct)*n + sizeof(int));

((int *)blockofMem)[0] = n;
mystruct *structs = (mystruct *)(((int *)blockOfMem) + 1);

Then you can always cast your arrays to int * and access the -1st element.

Be sure to free that pointer, and not the array pointer itself!

Also, this will likely cause terrible bugs that will leave you tearing your hair out. Maybe you can wrap the alloc funcs in API calls or something.

Claudiu
No good for portable code, as it doesn't work if mystruct contains any members with alignment requirement bigger than sizeof(int). Obviously not an issue on platforms where sizeof(int) is a multiple of the greatest alignment requirement of any type, but would break with eg -mfaster-structs on SPARC.
Steve Jessop
+2  A: 

For an array of pointers you can use a NULL-terminated array. The length can then determinate like it is done with strings. In your example you can maybe use an structure attribute to mark then end. Of course that depends if there is a member that cannot be NULL. So lets say you have an attribute name, that needs to be set for every struct in your array you can then query the size by:


int size;
struct mystruct *cur;

for (cur = myarray; cur->name != NULL; cur++)
    ;

size = cur - myarray;

Btw it should be calloc(n, sizeof(struct mystruct)) in your example.

quinmars
+3  A: 

Some compilers provide msize() or similar functions (_msize() etc), that let you do exactly that

dmityugov
It's called malloc_size on OSX.
dmckee
A: 

Other have discussed the limits of plain c pointers and the stdlib.h implementations of malloc(). Some implementations provide extensions which return the allocated block size which may be larger than the requested size.

If you must have this behavior you can use or write a specialized memory allocator. This simplest thing to do would be implementing a wrapper around the stdlib.h functions. Some thing like:

void* my_malloc(size_t s);     /* Calls malloc(s), and if successful stores 
                                  (p,s) in a list of handled blocks */
void my_free(void* p);         /* Removes list entry and calls free(p) */
size_t my_block_size(void* p); /* Looks up p, and returns the stored size */
...
dmckee
A: 

This is a test of my sort routine. It sets up 7 variables to hold float values, then assigns them to an array, which is used to find the max value.

The magic is in the call to myMax:

float mmax = myMax((float *)&arr,(int) sizeof(arr)/sizeof(arr[0]));

And that was magical, wasn't it?

myMax expects a float array pointer (float *) so I use &arr to get the address of the array, and cast it as a float pointer.

myMax also expects the number of elements in the array as an int. I get that value by using sizeof() to give me byte sizes of the array and the first element of the array, then divide the total bytes by the number of bytes in each element. (we should not guess or hard code the size of an int because it's 2 bytes on some system and 4 on some like my OS X Mac, and could be something else on others).

NOTE:All this is important when your data may have a varying number of samples.

Here's the test code:

#include <stdio.h>

float a, b, c, d, e, f, g;

float myMax(float *apa,int soa){
 int i;
 float max = apa[0];
 for(i=0; i< soa; i++){
  if (apa[i]>max){max=apa[i];}
  printf("on i=%d val is %0.2f max is %0.2f, soa=%d\n",i,apa[i],max,soa);
 }
 return max;
}

int main(void)
{
 a = 2.0;
 b = 1.0;
 c = 4.0;
 d = 3.0;
 e = 7.0;
 f = 9.0;
 g = 5.0;
 float arr[] = {a,b,c,d,e,f,g};

 float mmax = myMax((float *)&arr,(int) sizeof(arr)/sizeof(arr[0]));
 printf("mmax = %0.2f\n",mmax);

 return 0;
}
Wm J
I think you need to read the question again. In your answer you are using the name of a statically allocated array (`arr`) the question is about only having a pointer to a dynamically allocated array.
Charles Bailey
A: 

really your question is - "can I find out the size of a malloc'd (or calloc'd) data block". And as others have said: no, not in a standard way.

However there are custom malloc implementations that do it - for example http://dmalloc.com/

pm100