C++ Open a File and Read Line by Line

Important Terminology

What is the File Descriptor?
File descriptor is integer that uniquely identifies an open up file of the procedure.

File Descriptor tabular array: File descriptor table is the collection of integer array indices that are file descriptors in which elements are pointers to file table entries. One unique file descriptors tabular array is provided in operating system for each process.

File Tabular array Entry: File table entries is a structure In-memory surrogate for an open up file, which is created when procedure request to opens file and these entries maintains file position.

Standard File Descriptors: When whatever procedure starts, and then that process file descriptors table's fd(file descriptor) 0, one, ii open automatically, (By default) each of these 3 fd references file table entry for a file named /dev/tty

/dev/tty: In-memory surrogate for the terminal
Last: Combination keyboard/video screen

Read from stdin => read from fd 0 : Whenever we write any grapheme from keyboard, it read from stdin through fd 0 and salvage to file named /dev/tty.
Write to stdout => write to fd 1 : Whenever nosotros see any output to the video screen, it'south from the file named /dev/tty and written to stdout in screen through fd ane.
Write to stderr => write to fd 2 : Nosotros meet any error to the video screen, it is also from that file write to stderr in screen through fd ii.

I/O Arrangement calls

Basically there are total 5 types of I/O organisation calls:

one. Create: Used to Create a new empty file.

          Syntax in C linguistic communication:                    int create(char *filename, mode_t mode)

Parameter:

• filename : name of the file which you desire to create
• mode : indicates permissions of new file.

Returns:

• return first unused file descriptor (generally 3 when kickoff create use in process because 0, i, 2 fd are reserved)
• return -1 when error

How it work in OS

• Create new empty file on deejay
• Create file table entry
• Ready starting time unused file descriptor to point to file table entry
• Return file descriptor used, -1 upon failure

2. open up: Used to Open the file for reading, writing or both.

          Syntax in C language                    #include<sys/types.h> #include<sys/stat.h> #include <fcntl.h>   int open (const char* Path, int flags [, int mode ]);        

Parameters

• Path: path to file which y'all want to use
  • employ absolute path begin with "/", when you lot are not work in same directory of file.
  • Utilize relative path which is only file name with extension, when you are work in aforementioned directory of file.
• flags : How you like to utilize
  • O_RDONLY: read only, O_WRONLY: write only, O_RDWR: read and write, O_CREAT: create file if it doesn't exist, O_EXCL: prevent cosmos if information technology already exists

How it works in Bone

• Notice the existing file on disk
• Create file table entry
• Fix first unused file descriptor to point to file tabular array entry
• Return file descriptor used, -ane upon failure

C

#include<stdio.h>

#include<fcntl.h>

#include<errno.h>

extern int errno ;

int main()

{

int fd = open up( "foo.txt" , O_RDONLY | O_CREAT);

printf ( "fd = %d/n" , fd);

if (fd ==-one)

{

printf ( "Error Number % d\n" , errno );

perror ( "Program" );

}

return 0;

}

Output:

fd = three

3. shut: Tells the operating organisation you are done with a file descriptor and Shut the file which pointed past fd.

          Syntax in C language          #include <fcntl.h> int shut(int fd);        

Parameter:

• fd :file descriptor

Return:

• 0 on success.
• -1 on fault.

How information technology works in the OS

• Destroy file tabular array entry referenced by chemical element fd of file descriptor table
  – Every bit long every bit no other procedure is pointing to information technology!
• Set element fd of file descriptor tabular array to NULL

C

#include<stdio.h>

#include <fcntl.h>

int main()

{

int fd1 = open( "foo.txt" , O_RDONLY);

if (fd1 < 0)

{

perror ( "c1" );

exit (1);

}

printf ( "opened the fd = % d\n" , fd1);

if (close(fd1) < 0)

{

perror ( "c1" );

exit (1);

}

printf ( "airtight the fd.\due north" );

}

Output:

opened the fd = three closed the fd.

C

#include<stdio.h>

#include<fcntl.h>

int main()

{

int fd1 = open( "foo.txt" , O_RDONLY, 0);

shut(fd1);

int fd2 = open( "baz.txt" , O_RDONLY, 0);

printf ( "fd2 = % d\n" , fd2);

exit (0);

}

Output:

fd2 = 3

Here, In this lawmaking first open() returns 3 considering when primary process created, then fd 0, ane, 2 are already taken by stdin, stdout and stderr. So first unused file descriptor is 3 in file descriptor table. After that in close() system telephone call is costless it this 3 file descriptor then after gear up 3 file descriptor as null. So when we called second open(), so first unused fd is also three. So, output of this program is three.

4. read: From the file indicated by the file descriptor fd, the read() role reads cnt bytes of input into the retentiveness expanse indicated by buf. A successful read() updates the access time for the file.

          Syntax in C language                    size_t read (int fd, void* buf, size_t cnt);        

Parameters:

• fd: file descriptor
• buf: buffer to read data from
• cnt: length of buffer

Returns: How many bytes were actually read

• render Number of bytes read on success
• return 0 on reaching end of file
• return -1 on mistake
• render -1 on betoken interrupt

Of import points

• buf needs to point to a valid memory location with length not smaller than the specified size considering of overflow.
• fd should be a valid file descriptor returned from open up() to perform read functioning because if fd is Zippo then read should generate fault.
• cnt is the requested number of bytes read, while the render value is the actual number of bytes read. Likewise, some times read organisation call should read less bytes than cnt.

C

#include<stdio.h>

#include <fcntl.h>

int main()

{

int fd, sz;

char *c = ( char *) calloc (100, sizeof ( char ));

fd = open( "foo.txt" , O_RDONLY);

if (fd < 0) { perror ( "r1" ); leave (1); }

sz = read(fd, c, 10);

printf ( "called read(% d, c, 10). returned that"

" %d bytes were read.\north" , fd, sz);

c[sz] = '\0' ;

printf ( "Those bytes are as follows: % southward\n" , c);

}

Output:

called read(iii, c, x).  returned that 10 bytes  were read. Those bytes are as follows: 0 0 0 foo.

Suppose that foobar.txt consists of the 6 ASCII characters "foobar". And then what is the output of the following program?

C

#include<stdio.h>

#include<unistd.h>

#include<fcntl.h>

#include<stdlib.h>

int main()

{

char c;

int fd1 = open( "sample.txt" , O_RDONLY, 0);

int fd2 = open( "sample.txt" , O_RDONLY, 0);

read(fd1, &c, one);

read(fd2, &c, 1);

printf ( "c = %c\northward" , c);

go out (0);

}

Output:

c = f

The descriptors fd1 and fd2 each accept their own open file table entry, so each descriptor has its own file position for foobar.txt . Thus, the read from fd2 reads the first byte of foobar.txt , and the output is c = f, not c = o.

5. write: Writes cnt bytes from buf to the file or socket associated with fd. cnt should not exist greater than INT_MAX (defined in the limits.h header file). If cnt is cypher, write() simply returns 0 without attempting whatever other activeness.

#include <fcntl.h> size_t write (int fd, void* buf, size_t cnt);        

Parameters:

• fd: file descriptor
• buf: buffer to write data to
• cnt: length of buffer

Returns: How many bytes were actually written

• return Number of bytes written on success
• return 0 on reaching end of file
• render -1 on error
• return -ane on signal interrupt

Important points

• The file needs to be opened for write operations
• buf needs to be at to the lowest degree as long as specified by cnt because if buf size less than the cnt so buf will atomic number 82 to the overflow status.
• cnt is the requested number of bytes to write, while the return value is the actual number of bytes written. This happens when fd have a less number of bytes to write than cnt.
• If write() is interrupted by a bespeak, the event is one of the following:
  -If write() has not written any information however, information technology returns -1 and sets errno to EINTR.
  -If write() has successfully written some data, information technology returns the number of bytes it wrote before information technology was interrupted.

C

#include<stdio.h>

#include <fcntl.h>

main()

{

int sz;

int fd = open( "foo.txt" , O_WRONLY | O_CREAT | O_TRUNC, 0644);

if (fd < 0)

{

perror ( "r1" );

exit (1);

}

sz = write(fd, "hi geeks\n" , strlen ( "howdy geeks\north" ));

printf ( "chosen write(% d, \"hello geeks\\n\", %d)."

" It returned %d\due north" , fd, strlen ( "hello geeks\n" ), sz);

shut(fd);

}

Output:

called write(3, "howdy geeks\n", 12).  it returned xi

Hither, when you run into in the file foo.txt subsequently running the code, you get a "hello geeks". If foo.txt file already accept some content in it then write organisation phone call overwrite the content and all previous content are deleted and only "hello geeks" content will have in the file.

Print "how-do-you-do world" from the program without use any printf or cout office.

C

#include<stdio.h>

#include<string.h>

#include<unistd.h>

#include<fcntl.h>

int main ( void )

{

int fd[two];

char buf1[12] = "hullo world" ;

char buf2[12];

fd[0] = open( "foobar.txt" , O_RDWR);

fd[1] = open( "foobar.txt" , O_RDWR);

write(fd[0], buf1, strlen (buf1));

write(1, buf2, read(fd[1], buf2, 12));

shut(fd[0]);

close(fd[1]);

return 0;

}

Output:

hi world

In this code, buf1 assortment's string "hello world" is get-go write in to stdin fd[0] then after that this string write into stdin to buf2 array. Later that write into buf2 array to the stdout and print output " hello world ".
This article is contributed past Kadam Patel. If you like GeeksforGeeks and would like to contribute, you tin also write an article using write.geeksforgeeks.org or mail your commodity to review-squad@geeksforgeeks.org. See your article appearing on the GeeksforGeeks master page and assist other Geeks.
Please write comments if yous find anything wrong, or you want to share more data virtually the topic discussed above.

blakelytherip.blogspot.com

Source: https://www.geeksforgeeks.org/input-output-system-calls-c-create-open-close-read-write/

Share this post