Details about a pointer can easily be obtained and output: it’s name, address, and contents. Obtaining the size of the buffer it references, however, is a different animal.
\n
\nIn C, it’s up to the programmer to know the size of an allocated memory chunk. This value must be managed and adhered to lest the program do something ugly.<\/p>\n
But how does the computer know the size? How does the realloc()<\/em> function know how much memory to release or where to add memory?<\/p>\n While it’s up the C programmer to know these values, internally there must be a way to find out how much memory is associated with a pointer. One function available is malloc_usable_size()<\/em>, prototyped in the The function’s argument is a pointer. The value returned is a size_t<\/em>, representing the number of bytes available at the address saved in pointer This function isn’t without its quirks. First, it’s a GNU extension and not part of the standard C library. Second, the value returned is intended for research and debugging purposes. Because this is my goal, it’s why I choose to use this function.<\/p>\n The following program is an update from last week’s Lesson<\/a>. I added a series of printf()<\/em> statements to output values associated with the original buffer, the allocated buffer, and then re-allocated buffer.<\/p>\n Here’s a sample run:<\/p>\n The When malloc()<\/em> allocates 2048 bytes of storage, its address is returned and the size. The The size_t<\/em> value returned is 2056, eight bytes larger than what’s allocated. This result is typical for the malloc_usable_size()<\/em> function. The eight extra bytes are most likely processor overhead or used for memory alignment. This extra storage shouldn’t be accessed or used.<\/p>\n When the realloc()<\/em> function reallocates storage, the original memory address is retained. The new buffer size reported by malloc_usable_size()<\/em> is the actual size allocated. Again, this value is for diagnostic and debugging purposes.<\/p>\n I tried to come up with my own version of the realloc()<\/em> function, but I can’t duplicate whatever magic it performs. So I can just be thankful that it exists and use it as necessary.<\/p>\n","protected":false},"excerpt":{"rendered":" Time to look under the hood at what the malloc()<\/em> and realloc()<\/em> functions do. Continue reading malloc.h<\/code> header file. Here’s the man<\/em> page format:<\/p>\nsize_t malloc_usable_size (void *ptr);<\/code><\/p>\nptr<\/code>.<\/p>\n2024_08_24-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n#include <malloc.h>\r\n\r\nint main()\r\n{\r\n char string[] = \"Hello there!\";\r\n char *sp;\r\n\r\n printf(\"Original string: %s\\n\",string);\r\n printf(\"Original string's address: %p\\n\",string);\r\n printf(\"Original string's size: %zu\\n\",sizeof(string));\r\n\r\n \/* allocate way too much storage *\/<\/span>\r\n sp = malloc(2048);\r\n if( sp==NULL )\r\n {\r\n fprintf(stderr,\"Failed to allocate way too much storage\\n\");\r\n exit(1);\r\n }\r\n\r\n \/* copy the string into storage *\/<\/span>\r\n strcpy(sp,string);\r\n printf(\"String copied: '%s'\\n\",sp);\r\n printf(\"New storage address: %p\\n\",sp);\r\n printf(\"New storage size: %zu\\n\",malloc_usable_size(sp));\r\n\r\n \/* reallocate (re-size) the storage *\/<\/span>\r\n sp = realloc(sp,strlen(string)+1);\r\n if( sp==NULL )\r\n {\r\n fprintf(stderr,\"Failed to reallocate storage\\n\");\r\n exit(1);\r\n }\r\n printf(\"Storage reallocated: '%s'\\n\",sp);\r\n printf(\"Reallocated address: %p\\n\",sp);\r\n printf(\"Reallocated address size: %zu\\n\",malloc_usable_size(sp));\r\n\r\n \/* clean up *\/<\/span>\r\n free(sp);\r\n return(0);\r\n}<\/pre>\nOriginal string: Hello there!
\nOriginal string's address: 0x7ffed53ba57f
\nOriginal string's size: 13
\nString copied: 'Hello there!'
\nNew storage address: 0x5621ee48a6b0
\nNew storage size: 2056
\nStorage reallocated: 'Hello there!'
\nReallocated address: 0x5621ee48a6b0
\nReallocated address size: 24<\/code><\/p>\n%p<\/code> placeholder is used to obtain the original array’s address. You can prefix the name with an &<\/code> (address-of) operator or not; the result is the same. The sizeof<\/em> operator easily obtains the value of the original string, which is an array.<\/p>\n%zu<\/code> placeholder represents a size_t<\/em> value in a printf()<\/em> format string.<\/p>\n