{"id":4728,"date":"2021-05-01T00:01:01","date_gmt":"2021-05-01T07:01:01","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4728"},"modified":"2022-02-26T10:42:22","modified_gmt":"2022-02-26T18:42:22","slug":"putting-the-memset-function-to-work","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4728","title":{"rendered":"Putting the memset()<\/em> Function to Work"},"content":{"rendered":"

My approach for initializing a buffer is to use a loop and assign each byte a value such as zero or the null character, '\\0'<\/code>. It’s tedious, but necessary. And for the impatient, some functions are available to perform this task for you.
\n
\nThe following code shows how I typically initialize a buffer. This method works and it’s good code, especially for someone like me who is teaching programming and wants to illustrate multiple points:<\/p>\n

2021_05_01-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    char buffer[BUFSIZ];\r\n    int x = 0;\r\n\r\n    while( x<BUFSIZ )\r\n    {\r\n        buffer[x] = '\\0';\r\n        x++;\r\n    }\r\n    puts(\"Buffer initialized\");\r\n\r\n    return(0);\r\n}<\/pre>\n
The while<\/em> loop at Line 8 plows through character array buffer[]<\/code>, filling each element with the null character byte (Line 10). Simple. Elegant. Refer to last week’s Lesson<\/a> for info on the defined constant BUFSIZ<\/code>.<\/p>\n
The program outputs the text Buffer initialized<\/code>, which is accurate but useless.<\/p>\n
Another, more direct way to pack a buffer with a given byte value is to use the memset()<\/em> function. Prototyped in the string.h<\/code> header file, memset()<\/em> uses this format:<\/p>\n
void *memset(void *b, int c, size_t len);<\/code><\/p>\n
The function takes three arguments: b<\/code> for a char<\/em> buffer, c<\/code> for the character to pack into the buffer, and len<\/code> for the buffer’s size. The function returns the first argument, the buffer’s address.<\/p>\n
Here is an update to my code, showing how the memset()<\/em> function makes things tighter:<\/p>\n
2021_05_01-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    char buffer[BUFSIZ];\r\n\r\n    memset(buffer, '\\0', BUFSIZ);\r\n    puts(\"Buffer initialized\");\r\n\r\n    return(0);\r\n}<\/pre>\n
The while<\/em> loop from the first example is replaced by a single statement at Line 8:<\/p>\n
memset(buffer, '\\0', BUFSIZ);<\/code><\/p>\n
All the pieces are present: The buffer’s address, the character to fill, and the size. These appear in the first listing as well, but sprinkled throughout the code. Variable x<\/code> is no longer needed. The string.h<\/code> header file must be included; string functions are essentially memory-manipulation functions in C, which is why memset()<\/em> is found there.<\/p>\n
With the memset()<\/em> function, you can set any character code value for initializing the buffer. So if you want a buffer filled with the letter A, you set 'A'<\/code> as the second argument. But when you need to fill a buffer with null characters, you can instead use the handy (yet non-standard) bzero()<\/em> function. Here is its format:<\/p>\n
void bzero(void *s, size_t n);<\/code><\/p>\n
Argument s<\/code> is the char<\/em> buffer to fill with null characters. Argument n<\/code> is the buffer’s size in bytes. This function is prototyped in the strings.h<\/code> header file. Many compilers include this header file when you use string.h<\/code>, though for conformity I specify strings.h<\/code> directly in the following code:<\/p>\n
2021_05_01-Lesson-c.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <strings.h>\r\n\r\nint main()\r\n{\r\n    char buffer[BUFSIZ];\r\n\r\n    bzero(buffer, BUFSIZ);\r\n    puts(\"Buffer initialized\");\r\n\r\n    return(0);\r\n}<\/pre>\n
The bzero()<\/em> function appears at Line 8, replacing memset()<\/em> from the preceding example. The program’s output is the same, though unlike memset()<\/em>, bzero()<\/em> always fills a buffer with null characters.<\/p>\n
I find memset()<\/em> and bzero()<\/em> to be delightful options for initializing a buffer. Still, I may write my own loops out of habit. Nothing wrong with that.<\/p>\n","protected":false},"excerpt":{"rendered":"
Here’s a quick and effective way to initialize a buffer. 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-4728","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\/4728","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=4728"}],"version-history":[{"count":6,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4728\/revisions"}],"predecessor-version":[{"id":5244,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4728\/revisions\/5244"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4728"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4728"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4728"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}