Thread: Determining the sizeof dynamically allocated memory in C programming

<< !! Posting Code? Read this First !! >>
If you're going to use C, you need to keep track of the size. Higher-level languages such as C++ allows you to escape this need, however.

Originally Posted by Elysia

If you're going to use C, you need to keep track of the size. Higher-level languages such as C++ allows you to escape this need, however.

C++ also does not provide any means to extract an allocated length if all you have is a pointer.

The C++ library types (eg string, vector) keep track of the length of their contents, so it is possible (say) to determine how many elements are currently in a vector. As noted in previous posts, if you want to achieve that in C, you need to "roll your own" (i.e. keep track of the length yourself).

Originally Posted by grumpy

C++ also does not provide any means to extract an allocated length if all you have is a pointer.

The C++ library types (eg string, vector) keep track of the length of their contents, so it is possible (say) to determine how many elements are currently in a vector. As noted in previous posts, if you want to achieve that in C, you need to "roll your own" (i.e. keep track of the length yourself).

And maybe all of this is for the better. IMO not caring about remembering how much memory you allocate is kind of like not caring about the speed you are driving at.

Originally Posted by grumpy

C++ also does not provide any means to extract an allocated length if all you have is a pointer.

I did say "escape", not a magical solution. Yes, if you have a pointer, then you don't know the size. But with templates, the compiler can help you remember the size (you can pass arrays be real reference in C++ actually, letting the compiler help you remember the size).
And the standard library does remember its size. And then there's the standard arrays types std::vector and std::array which also keeps track of their size.

Unfortunately, no such thing i n C.

Originally Posted by Elysia

I did say "escape", not a magical solution.

I realised what you meant. However, not everyone would read your words with sufficient precision to avoid misunderstanding or misinterpretation.

Very well, then. Now that's we've elaborated on the matter, perhaps it's point will get across better

Fortunately, it's not so difficult to do in C.
Just write a wrapper over malloc/calloc/realloc/free.
EDIT:
2nd EDIT: apology that i forgot to return p->data instead of p!
The code is not tested. Use @ your own risk.

Code:

struct mem {
   void *data;
   size_t nbytes;
} ;
typedef struct mem mem;
void *my_malloc(size_t n)
{
   mem *p;
   p = malloc( sizeof(*p) + n );
   if(p == NULL) return NULL;
   p->nbytes = n;
   p->data     =   p + 1;        // tricky!
   return p->data;
}
void my_free(void *memp)
{
    mem *p = memp;
    if(p == NULL) return ;        // behave just like free()
    p--;                                    // tricky!
    free(p);
}
size_t GetSize(void *memp)
{
    mem *p = memp;
    p--;                                 
    return p->nbytes;
}
int main(void)
{
     char *str = my_malloc( 100 );
     double *vec = my_malloc( 10 * sizeof(*vec) );
     // error check omitted
     printf("str bytes = %lu\n", GetSize(str) );
    my_free(str);
    my_free(vec);
    return 0;
}

Of course, you might want to abstract the implementation.

It seems a little pointless to allocate the structure itself. You are increasing the memory need by a lot. It would probably be better to copy the small struct instead. Or pass in a pointer to the struct that you can modify.

Actually nevermind. Did I read the code wrong last time or did you change it?
Although, you are using mem and not struct mem and you're not typedefing the struct. Bug?