{"id":5248,"date":"2022-03-19T00:01:38","date_gmt":"2022-03-19T07:01:38","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=5248"},"modified":"2022-03-12T10:13:40","modified_gmt":"2022-03-12T18:13:40","slug":"initializing-a-buffer-your-own-memset-function","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=5248","title":{"rendered":"Initializing a Buffer – Your Own memset()<\/em> Function"},"content":{"rendered":"

As I wrote in last week’s Lesson<\/a>, the C23 standard renders the memset()<\/em> function — a standard C library function for over 30 years — obsolete. If you want to initialize a buffer, you can use the secure memset_s()<\/em> or just initialize the buffer manually or with your own memset()<\/em>-like function.
\n
\nAlas, the parade of safe C functions isn’t widely supported. Each of these functions shares a name with their “unsafe” (or easily abused) counterparts, but with the _s<\/em> suffix. This rule is true for memset()<\/em>, where the safe version is named memset_s()<\/em>. Because these safe functions are inconsistently implemented, a definitive method to detect their inclusion with any compiler isn’t available. So if you want to use a safer version of memset()<\/em>, and memset_s()<\/em> isn’t available to your compiler, you must code your own or just manually initialize a buffer.<\/p>\n

The following code zeroes out the human<\/code> structure variable my<\/code>:<\/p>\n

2022_03_19-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    struct human {\r\n        char name[32];\r\n        int age;\r\n        float weight;\r\n    } my;\r\n    int x;\r\n\r\n    for( x=0; x<32; x++)\r\n        my.name[x] = '\\0';\r\n    my.age = 0;\r\n    my.weight = 0.0;\r\n\r\n    return(0);\r\n}<\/pre>\n
The for<\/em> loop at Line 12 initializes all 32 elements of the name array member to the null character, \\0<\/code>. Lines 14 and 15 set the other two structure members to zero. This process effectively initializes the buffer, removing whatever garbage already exists in memory.<\/p>\n
The program has no output, though I ran it through the Code::Blocks debugger to watch as the relevant memory chunk was cleared. Figure 1 illustrates the before (above) and after (below) effect of clearing the structure’s memory.<\/p>\n
\"\"
Figure 1. A memory dump from the Code::Blocks debugger, showing before (above) and after( below).<\/p><\/div>\n
The problem with this approach is that it’s specific to one type of structure. A better approach is to zero out memory as a buffer — the entire thing — regardless of its specific data type contents. This approach is used in the following code update:<\/p>\n
2022_03_19-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    struct human {\r\n        char name[32];\r\n        int age;\r\n        float weight;\r\n    } my;\r\n    int x;\r\n    char *b;\r\n\r\n    b = (char *)&my;\r\n    for( x=0; x<sizeof(struct human); x++)\r\n        *(b+x) = 0;\r\n\r\n    return(0);\r\n}<\/pre>\n
This code adds char<\/em> pointer b<\/code>. Its value is set to the address of human<\/code> struct<\/em> variable my<\/code> at Line 13, which is typecast as a char<\/em> pointer. Remember that in C, a char<\/em> is sorta kinda the same as a byte. The for<\/em> loop then initializes the entire structure’s contents to zero, using the sizeof<\/em> operator to return the structure’s size in memory.<\/p>\n
Of course, it would be better to put the zeroing code into a function, as is done here:<\/p>\n
2022_03_19-Lesson-c.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nvoid memzero(void *b, int len)\r\n{\r\n    int x;\r\n    char *a;\r\n\r\n    a = (char *)b;\r\n    for( x=0; x<len; x++)\r\n        *(a+x) = 0;\r\n}\r\n\r\nint main()\r\n{\r\n    struct human {\r\n        char name[32];\r\n        int age;\r\n        float weight;\r\n    } my;\r\n\r\n    memzero(&my,sizeof(struct human));\r\n\r\n    return(0);\r\n}<\/pre>\n
The memzero()<\/em> function has a void<\/em> pointer as its first argument and the buffer size as its second. The void<\/em> data type allows any pointer to be passed, such as the address of human<\/code> structure my<\/code> at Line 21. The structure, not being a pointer itself, is prefixed with the &, address-of operator.<\/p>\n
Within the memzero()<\/em> function, the void<\/em> pointer b<\/code> is assigned to char<\/em> pointer a<\/code> for processing. The result is the same: The buffer is initialized to zero. So this function works as a replacement for memset()<\/em>, but it’s still subject to compiler optimization.<\/p>\n
To disable compiler optimization, use the command line switch -O0<\/code> (capital O, zero). This switch is the default, so it may not have any effect on your code.<\/p>\n
A better approach is to classify int<\/em> variable x<\/code> as volatile<\/em> at Line 5:<\/p>\n
volatile int x;<\/code><\/p>\n
The volatile<\/em> qualifier directs the compiler not to mess with variable x<\/code>, which should ensure that the loop is processed completely and not optimized in any way. Better than using this trick is to find a compiler that supports the memset_s()<\/em> function, or just wait until the C23 release becomes standard.<\/p>\n","protected":false},"excerpt":{"rendered":"
The memset()<\/em> function is deemed insecure, so why not code your own version?  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-5248","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\/5248","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=5248"}],"version-history":[{"count":4,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/5248\/revisions"}],"predecessor-version":[{"id":5258,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/5248\/revisions\/5258"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=5248"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=5248"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=5248"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}