{"id":4036,"date":"2020-03-21T00:01:28","date_gmt":"2020-03-21T07:01:28","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4036"},"modified":"2020-05-16T08:10:58","modified_gmt":"2020-05-16T15:10:58","slug":"opening-a-file-in-the-raw","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4036","title":{"rendered":"Opening a File in the Raw"},"content":{"rendered":"

The fopen()<\/em> function opens a file or stream for formatted input. The “formatted” is where the function gets its f<\/em> prefix, which I always thought stood for file<\/em>. It doesn’t. The fopen()<\/em> function is the formatted file (and stream) function, the open()<\/em> function is for low-level, unformatted file access.
\n
\nRare is the beginner book or tutorial that covers the open()<\/em> function, primarily because it deals with low-level, unformatted file access and it’s not really required to open a file. Therefore, it’s skipped or glossed over. Yet, the function is worth some discovery.<\/p>\n

Before exploring the open()<\/em> function, here’s an example of the fopen()<\/em> function, which accesses the file gettysburg.txt<\/a><\/code> and sends its contents to standard output:<\/p>\n

\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    const char filename[] = \"gettysburg.txt\";\r\n    FILE *fp;\r\n    int ch;\r\n\r\n    fp = fopen(filename,\"r\");\r\n    if( fp==NULL )\r\n    {\r\n        fprintf(stderr,\"Unable to open %s\\n\",filename);\r\n        return(1);\r\n    }\r\n\r\n    while( !feof(fp) )\r\n    {\r\n        ch = fgetc(fp);\r\n        if( ch==EOF )\r\n            break;\r\n        fputc(ch,stdout);\r\n    }\r\n    fclose(fp);\r\n\r\n    return(0);\r\n}<\/pre>\n
The fopen()<\/em> function’s arguments are a filename string and a string representing the opening mode. The value returned is a FILE<\/em> pointer, a handle containing details and other trivia about the open file. Upon success, the file is opened for formatted input and output, depending upon the second argument.<\/p>\n
The open()<\/em> function, on the other hand, offers a different definition. Prototyped in the fnctl.h<\/code> header, here’s its man<\/em> page (2) format:<\/p>\n
int open(const char *path, int oflag, ...<\/a>);<\/code><\/p>\n
The first argument (const char *path<\/code>) is the same as fopen()<\/em>, a filename string or the pathname to a device to open. The argument (oflag<\/code>) is one or more constant expressions or flags that set how the file is to be opened. These constants, also defined in fnctl.h<\/code>, must include one of these three:<\/p>\n
O_RDONLY<\/code> Open the file read-only.
\nO_WRONLY<\/code> Open the file write-only.
\nO_RDWR<\/code> Open the file for reading and writing.<\/p>\n
Additional flags set a specific file-opening mode and are logically OR’d with each other. For example, the O_CREAT<\/code> flag creates a file that doesn’t exist; unlike the fopen()<\/em> function, using open()<\/em> on a file that doesn’t exist without specifying the O_CREAT<\/code> flag returns an error.<\/p>\n
The third argument is documented differently, depending on the source. I have no idea what it does, but it’s not required for the examples on this blog.<\/p>\n
The open()<\/em> function returns a non-negative integer value, a file descriptor. Upon failure, the value -1 is returned. This return value is a huge difference between open()<\/em> and fopen()<\/em>.<\/p>\n
File descriptor values range from zero on up, with file descriptors 0, 1, and 2 all preset (and reserved) by the operating system to the following standard I\/O devices: standard input (stdin<\/em>), standard output (stdout<\/em>), and standard error (stderr<\/em>), respectively. These constants are also defined in the unistd.h<\/code> header file as: STDIN_FILENO<\/code>, STDOUT_FILENO<\/code>, and STDERR_FILENO<\/code>.<\/p>\n
Just as the companion to fopen()<\/em> is open()<\/em>, the companion to fclose()<\/em> is close()<\/em>. This function is defined in the unistd.h<\/code> header file (not fcntl.h<\/code>), and it requires a single argument, the file descriptor integer returned by the open()<\/em> function.<\/p>\n
The following code opens the file gettysburg.txt<\/code> as did the first example, but uses the open()<\/em> function. The file is opened and closed; no data is read.<\/p>\n
\r\n#include <stdio.h>\r\n#include <fcntl.h>\r\n#include <unistd.h>\r\n\r\nint main()\r\n{\r\n    const char filename[] = \"gettysburg.txt\";\r\n    int fdes;\r\n\r\n    fdes = open(filename,O_RDONLY);\r\n    if( fdes==-1 )\r\n    {\r\n        fprintf(stderr,\"Unable to open %s\\n\",filename);\r\n        return(1);\r\n    }\r\n\r\n    printf(\"'%s' opened for low-level, unformatted reading\\n\",filename);\r\n\r\n    close(fdes);\r\n\r\n    return(0);\r\n}<\/pre>\n
At Line 10, the open()<\/em> function opens the file gettysberg.txt<\/code> (referenced by variable filename<\/code>) in read-only mode. The file descriptor returned is kept in the fdes<\/code> variable, which is tested at Line 11.<\/p>\n
Line 19 closes the opened file, using the close()<\/em> function with file descriptor variable fdes<\/code>.<\/p>\n
Here’s a sample run:<\/p>\n
'gettysburg.txt' opened for low-level, unformatted reading<\/code><\/p>\n
In next week’s Lesson<\/a>, I explore reading text from a file opened by using the open()<\/em> function, and sending the text to standard output.<\/p>\n","protected":false},"excerpt":{"rendered":"
The common C library function to open a file is fopen()<\/em>, but the open()<\/em> function also exists. What’s the difference? 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-4036","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\/4036","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=4036"}],"version-history":[{"count":6,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4036\/revisions"}],"predecessor-version":[{"id":4146,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4036\/revisions\/4146"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4036"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4036"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4036"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}