{"id":6285,"date":"2024-03-09T00:01:05","date_gmt":"2024-03-09T08:01:05","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=6285"},"modified":"2024-02-24T16:57:57","modified_gmt":"2024-02-25T00:57:57","slug":"the-alloca-function","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=6285","title":{"rendered":"The alloca()<\/em> Function"},"content":{"rendered":"

Any memory allocated in a function is retained when the function leaves, unless you first free it. This rule applies to all memory allocation functions — except one.
\n
\nOf course, memory allocated in the main()<\/em> function is freed when it returns (the program exits). This is the reason why I’m often lazy and forget to free memory at the end of the main()<\/em> function, a sin for which I repent. But an exception to the memory allocation\/freeing rule is the alloca()<\/em> function.<\/p>\n

Like an auto<\/em> variable, the alloca()<\/em> function’s scope is local to the function it’s used in: Memory is allocated, but released when the next function is called. It’s not released upon return from the function (though this aspect may be undefined), but when you call another function the memory alloca()<\/em> allocated is gone.<\/p>\n

To demonstrate the alloca()<\/em> function, I first wrote code that uses malloc()<\/em> to allocate and use a buffer:<\/p>\n

2024_03_09-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n\r\nchar *astring(void)\r\n{\r\n    const int size = 12;\r\n    char *a;\r\n    int x;\r\n\r\n    a = malloc(size+1);\r\n    for( x=0; x<size; x++ )\r\n        *(a+x) = 'A';\r\n    *(a+x) = '\\0';\r\n\r\n    printf(\"Allocated string: '%s'\\n\",a);\r\n\r\n    return a;\r\n}\r\n\r\nvoid header(void)\r\n{\r\n    puts(\"After temporary allocation\");\r\n}\r\n\r\nint main()\r\n{\r\n    char *alpha;\r\n    puts(\"Temporary allocation\");\r\n    alpha = astring();\r\n\r\n    header();\r\n    printf(\"Allocated string: '%s'\\n\",alpha);\r\n    free(alpha);\r\n\r\n    return 0;\r\n}<\/pre>\n
The astring()<\/em> function allocates 13 bytes of char<\/em> storage, which is assigned characters and output. I don’t test the allocation for failure, which is something you must do in your own code. Here, allocating 13 bytes shouldn’t be an issue.<\/p>\n
The main()<\/em> function saves the pointer returned from astring()<\/em> in variable alpha<\/code>. Before outputting the string, the header()<\/em> function is called. Yes, this is weird code, but it’s designed to demonstrate how the alloca()<\/em> function works: A second function must be called to free the memory (according to the docs). Here’s the ouput:<\/p>\n
Temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'
\nAfter temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'<\/code><\/p>\n
To update the code with alloca()<\/em> instead of malloc()<\/em> these changes are made: stdlib.h<\/code> is replaced by alloca.h<\/code>; malloc()<\/em> is replaced by alloca()<\/em>; and the free()<\/em> statement is removed from the main()<\/em> function. You can click here<\/a> to view the updated version of the code on GitHub.<\/p>\n
Here is the output when clang<\/em> builds the program:<\/p>\n
Temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'
\nAfter temporary allocation
\nAllocated string: ''<\/code><\/p>\n
The string is zapped after the call to the header()<\/em> function.<\/p>\n
Being curious, I ran a few tests to confirm how the alloca()<\/em> function works. If I don’t call the header()<\/em> function, the allocated string is output:<\/p>\n
Temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'
\nAfter temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'<\/code><\/p>\n
I had assumed that the allocated storage was released when the function call returned. The man<\/em> page says that alloca()<\/em>‘s memory is released when another function is called, which is why the original code called the header()<\/em> function.<\/p>\n
When I tested the code with the GNU compiler, the memory doesn’t seem to be released. Here is the program’s output when built with gcc<\/em>:<\/p>\n
Temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'
\nAfter temporary allocation
\nAllocated string: 'AAAAAAAAAAAA'<\/code><\/p>\n
Though it looks like the allocated memory is intact, if you attempt to free()<\/em> the pointer’s address you get an invalid pointer message as the program runs. This error message appears for programs built by both clang<\/em> and gcc<\/em>. So I guess the memory is released when built with gcc<\/em> but something quirky is keeping the contents around. It could just be my own system.<\/p>\n
I can’t think of an application where the alloca()<\/em> function is necessary, especially given that memory can always be freed. Yet this function is available in some C libraries and must have some purpose.<\/p>\n","protected":false},"excerpt":{"rendered":"
Here’s a function you can use when you need to forget to free memory on purpose. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-6285","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6285","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=6285"}],"version-history":[{"count":5,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6285\/revisions"}],"predecessor-version":[{"id":6296,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6285\/revisions\/6296"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=6285"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=6285"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=6285"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}