{"id":6013,"date":"2023-09-02T00:01:23","date_gmt":"2023-09-02T07:01:23","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=6013"},"modified":"2023-09-09T09:09:27","modified_gmt":"2023-09-09T16:09:27","slug":"opening-and-closing-memory-files","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=6013","title":{"rendered":"Opening and Closing Memory-Files"},"content":{"rendered":"

To treat a chunk of memory as a file, it must be “opened” and a handle returned for future file reference and interaction. Likewise, the memory-file must be “closed” when you no longer need it. To accomplish these tasks, I’ve crafted the mem_open()<\/em> and mem_close()<\/em> functions.
\n
\nBoth of these functions use a mem_file<\/em> structure, introduced in last week’s Lesson<\/a>. The mem_open()<\/em> function swallows a string to represent the memory-file name. It returns a pointer to a mem_file<\/em> structure upon success, NULL<\/code> otherwise.<\/p>\n

The mem_close()<\/em> function requires a mem_file<\/em> structure pointer as an argument. It has no return value.<\/p>\n

The following code uses these functions to create a memory-file then close the memory file.<\/p>\n

2023_09_02-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <time.h>\r\n\r\n#define DEFAULT_SIZE 2048\r\n\r\nstruct mem_file {\r\n    void *address;\r\n    char *name;\r\n    int size;\r\n    int offset;\r\n    char *timestamp;\r\n};\r\n\r\n\/* create a memory file\r\n   input: filename string\r\n   output: pointer to memory file structure,\r\n           NULL on failure\r\n *\/<\/span>\r\nstruct mem_file *mem_open(char *fn)\r\n{\r\n    struct mem_file *mem_new;\r\n    time_t now;\r\n\r\n    \/* error checking *\/<\/span>\r\n    if( fn==NULL )\r\n        return(NULL);\r\n\r\n    \/* allocate storage for memory file structure *\/<\/span>\r\n    mem_new = malloc( sizeof(struct mem_file) );\r\n    if( mem_new==NULL )\r\n        return(NULL);\r\n\r\n    \/* populate structure *\/<\/span>\r\n    mem_new->address = malloc( DEFAULT_SIZE );\r\n    if( mem_new->address==NULL )\r\n        return(NULL);\r\n    mem_new->name=fn;        \/* set memory file name *\/<\/span>\r\n    mem_new->size = 0;        \/* set size *\/<\/span>\r\n    mem_new->offset = 0;    \/* offset\/file pointer *\/<\/span>\r\n        \/* create timestemp *\/<\/span>\r\n    time(&now);\r\n    mem_new->timestamp = ctime(&now);\r\n\r\n    return(mem_new);\r\n}\r\n\r\n\/*\r\n   close memory file, free memory\r\n   input: mem_file structure of an open\r\n           memory file\r\n *\/<\/span>\r\nvoid mem_close(struct mem_file *m)\r\n{\r\n    free(m->address);\r\n    free(m);\r\n}\r\n\r\n\/* test the memory file functions *\/<\/span>\r\nint main()\r\n{\r\n    static char name1[] = \"memory file\";\r\n    struct mem_file *mfp1;\r\n\r\n    mfp1 = mem_open(name1);\r\n    if( mfp1==NULL )\r\n    {\r\n        fprintf(stderr,\"Unable to create %s\\n\",name1);\r\n        exit(1);\r\n    }\r\n\r\n    printf(\"Memory file '%s' created\\n\",name1);\r\n    printf(\"Timestamp = %s\\n\",mfp1->timestamp);\r\n\r\n    printf(\"Press Enter: \");\r\n    getchar();\r\n\r\n    mem_close(mfp1);\r\n    printf(\"Memory file '%s' closed\\n\",name1);\r\n\r\n    return(0);\r\n}<\/pre>\n
The mem_open()<\/em> function immediately checks for an empty string and returns NULL when no string is specified:<\/p>\n
if( fn==NULL )
\n    return(NULL);<\/code><\/p>\n
Next, memory is allocated for the mem_file<\/em> structure. This step takes place first and, upon success, memory is then allocated for the memory-file itself based upon the value of DEFAULT_SIZE<\/code>. If either allocation fails, NULL<\/code> is returned.<\/p>\n
The remainder of the mem_open()<\/em> function assigns values to the members: the filename, the memory_file size, offset, and timestamp string. The mem_file<\/em> structure’s address is then returned.<\/p>\n
The mem_close()<\/em> function contains only two statements. The first frees the memory-file’s allocated storage, saved in member address<\/em>. The second statement frees the mem_file<\/em> structure itself.<\/p>\n
The main()<\/em> function creates a memory-file. It outputs the memory-file’s timestamp, waits for a key press, then closes the memory-file. Here’s sample output:<\/p>\n
Memory file 'memory file' created
\nTimestamp = Sat Sep  2 10:02:13 2023<\/p>\n
Press Enter:
\nMemory file 'memory file' closed<\/code><\/p>\n
Because these functions worked so well, I decided to modify the code to open a second memory-file. I wanted to ensure that a second memory-file wouldn’t contaminate the first. This code is available on GitHub<\/a>, and here is its output:<\/p>\n
Memory file 'memory file' created
\nTimestamp = Sat Aug 19 10:05:10 2023<\/p>\n
Press Enter:
\nMemory file 'memory file two' created
\nTimestamp = Sat Aug 19 10:05:12 2023<\/p>\n
Memory file 'memory file' closed
\nMemory file 'memory file two' closed<\/code><\/p>\n
The Press Enter<\/code> prompt helps to ensure that both memory-files don’t have identical timestamps.<\/p>\n
Unlike media files, when these memory-files are closed, they’re gone for good. Memory-files don’t linger in memory ready to be re-opened. For that to happen, I’d need to implement a memory-file file system. That’s too much work! My approach here is to mimic file access by using a chunk of memory.<\/p>\n
Next week<\/a> I continue this exploration with functions to write to and read from the memory-file.<\/p>\n","protected":false},"excerpt":{"rendered":"
To treat a chunk of memory as a file, you must have memory-file open and close functions. 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-6013","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\/6013","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=6013"}],"version-history":[{"count":5,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6013\/revisions"}],"predecessor-version":[{"id":6034,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6013\/revisions\/6034"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=6013"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=6013"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=6013"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}