How to calloc() 25 byte exactly

Question

I want to calloc 25 bytes of memory exactly. In this case, msg_len = 5 bytes, since that is what the input is. This is the code I have:

  int full_msg_size = 20 + msg_len;
  printf("full_msg_size: %d\n", full_msg_size);
  void *full_msg = calloc(full_msg_size, sizeof(char));
  printf("size of full_msg: %d\n", (int*)sizeof(full_msg));

This is what prints out:

full_msg_size: 25 size of full_msg: 8

But I want size of full_msg to equal 25 bytes just like full_msg_size.

I also want all the memory spaces initialized to zero.

Can anyone tell me how to calloc/malloc this properly?

Thanks

Answer 1

In the context of your post, it seems that you really want to determine the length of a string contained by a variable, as opposed to the size of the variable. sizeof when applied to a pointer, will tell you the size of the address, not the length of the string. If you need to determine the length of a string at runtime, use the function strlen:

`int len = strlen(some_str)`    

You may be getting full_msg_size: 25 size of full_msg: 8 because sizeof
is returning the size of the address of full_msg.

So, your function:

printf("size of full_msg: %d\n", (int*)sizeof(full_msg));  

Should be:

printf("length of full_msg: %d\n", strlen(full_msg));

if you want to want to calloc 25 bytes of memory exactly:

char *full_msg = {0};
full_msg = calloc(25, 1); //all space initialized to 0     
//or you can also use:  
full_msg = malloc(25);  

full_msg now has memory for exactly 25 bytes, (but one needs to be used for '\0')

The sizeof operator when used on a char *str, returns to you the size of a char *, which is just an address.

Note: The size of an address (or pointer) will not always be 8 bytes just because you are running a 64 bit machine, it depends on what the application is compiled to: 32bit or 64bit. i.e., For a 32 but application, size of an address is 4 bytes, for a 64 bit application, it will be 8 bytes.

Answer 2

You are most likely allocating the correct number of bytes but you are asking how big a pointer to a void is. And on a 64 bit box it will very likely be 8 bytes. If it failed to allocate the amount of memory you asked for then full_message would have the value NULL.

Answer 3

The sizeof operator is (almost always) a compile-time operator (exception: VLAs). So the sizeof some pointer is always the same (on your machine, it is always 8) and does not depend of the size passed to some malloc or calloc function.

Given a malloc-ed or calloc-ed pointer, there is no portable way to know the size requested at its allocation time. You should keep that size somewhere! You might use a flexible array member like here if you wanted to keep that dynamic size inside the allocated structure. You often keep the size elsewhere i.e. in some variable (full_msg_size in your case).

So your calloc is working (BTW, you should test it against failure).

void *full_msg = calloc(full_msg_size, 1);
if (!full_msg) {perror("calloc"); exit(EXIT_FAILURE); };

But you cannot use sizeof to compute the runtime size of the allocated zone.

Answer 4

You are printing size of pointer which will be 8 bytes in the case of 64-bit machines.