Create a C++ Function That Reads a Text File via Posix Calls and Returns a Pointer to Its Contents

Important Terminology

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

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

File Table Entry: File table entries is a construction In-retentiveness surrogate for an open file, which is created when process request to opens file and these entries maintains file position.

Standard File Descriptors: When any process starts, then that process file descriptors tabular array's fd(file descriptor) 0, one, two open automatically, (By default) each of these three fd references file table entry for a file named /dev/tty

/dev/tty: In-memory surrogate for the concluding
Terminal: Combination keyboard/video screen

Read from stdin => read from fd 0 : Whenever we write any character from keyboard, it read from stdin through fd 0 and relieve to file named /dev/tty.
Write to stdout => write to fd ane : Whenever nosotros meet any output to the video screen, it'southward from the file named /dev/tty and written to stdout in screen through fd 1.
Write to stderr => write to fd 2 : We see whatever fault to the video screen, it is too from that file write to stderr in screen through fd ii.

I/O Organization calls

Basically in that location are full 5 types of I/O system calls:

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

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

Parameter:

• filename : proper noun of the file which you want to create
• fashion : indicates permissions of new file.

Returns:

• return outset unused file descriptor (more often than not three when showtime create use in process because 0, 1, two fd are reserved)
• return -1 when error

How it work in Os

• Create new empty file on deejay
• Create file table entry
• Gear up outset unused file descriptor to point to file table entry
• Return file descriptor used, -1 upon failure

2. open: Used to Open up 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 fashion ]);        

Parameters

• Path: path to file which yous want to apply
  • utilize absolute path begin with "/", when you are not work in same directory of file.
  • Use relative path which is but file name with extension, when you are work in same directory of file.
• flags : How you like to use
  • 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 creation if it already exists

How it works in OS

• Find the existing file on deejay
• Create file table entry
• Set first unused file descriptor to bespeak to file tabular array entry
• Return file descriptor used, -1 upon failure

C

#include<stdio.h>

#include<fcntl.h>

#include<errno.h>

extern int errno ;

int main()

{

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

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

if (fd ==-i)

{

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

perror ( "Program" );

}

return 0;

}

Output:

fd = 3

3. shut: Tells the operating system you lot are washed with a file descriptor and Close the file which pointed past fd.

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

Parameter:

• fd :file descriptor

Render:

• 0 on success.
• -1 on error.

How it works in the OS

• Destroy file table entry referenced by chemical element fd of file descriptor tabular array
  – As long as no other process is pointing to it!
• Set element fd of file descriptor table to NULL

C

#include<stdio.h>

#include <fcntl.h>

int principal()

{

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

if (fd1 < 0)

{

perror ( "c1" );

exit (one);

}

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

if (close(fd1) < 0)

{

perror ( "c1" );

exit (i);

}

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

}

Output:

opened the fd = 3 closed the fd.

C

#include<stdio.h>

#include<fcntl.h>

int principal()

{

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

close(fd1);

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

printf ( "fd2 = % d\due north" , fd2);

exit (0);

}

Output:

fd2 = 3

Here, In this lawmaking first open() returns iii because when main process created, then fd 0, one, ii are already taken by stdin, stdout and stderr. And then beginning unused file descriptor is three in file descriptor table. After that in close() system phone call is free it this iii file descriptor and then after fix 3 file descriptor as null. So when we called second open(), then first unused fd is also iii. So, output of this program is 3.

4. read: From the file indicated past the file descriptor fd, the read() function reads cnt bytes of input into the memory area indicated by buf. A successful read() updates the admission fourth dimension for the file.

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

Parameters:

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

Returns: How many bytes were actually read

• return Number of bytes read on success
• return 0 on reaching end of file
• return -1 on fault
• return -one on signal interrupt

Important points

• buf needs to point to a valid retention location with length not smaller than the specified size considering of overflow.
• fd should be a valid file descriptor returned from open() to perform read performance considering if fd is Cypher and so read should generate mistake.
• cnt is the requested number of bytes read, while the render value is the actual number of bytes read. Also, some times read arrangement call should read less bytes than cnt.

C

#include<stdio.h>

#include <fcntl.h>

int principal()

{

int fd, sz;

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

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

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

sz = read(fd, c, 10);

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

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

c[sz] = '\0' ;

printf ( "Those bytes are as follows: % due south\north" , c);

}

Output:

chosen read(3, c, 10).  returned that 10 bytes  were read. Those bytes are every bit follows: 0 0 0 foo.

Suppose that foobar.txt consists of the six ASCII characters "foobar". 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 up( "sample.txt" , O_RDONLY, 0);

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

read(fd1, &c, 1);

read(fd2, &c, 1);

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

exit (0);

}

Output:

c = f

The descriptors fd1 and fd2 each have their own open file tabular array entry, so each descriptor has its own file position for foobar.txt . Thus, the read from fd2 reads the start 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 be greater than INT_MAX (defined in the limits.h header file). If cnt is zero, write() simply returns 0 without attempting any other action.

#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 really written

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

Important points

• The file needs to exist opened for write operations
• buf needs to exist at least every bit long as specified by cnt because if buf size less than the cnt then buf volition lead to the overflow condition.
• cnt is the requested number of bytes to write, while the render 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 signal, the effect is one of the following:
  -If write() has not written any data yet, information technology returns -one and sets errno to EINTR.
  -If write() has successfully written some data, it returns the number of bytes it wrote before it was interrupted.

C

#include<stdio.h>

#include <fcntl.h>

primary()

{

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 ( "hello geeks\n" ));

printf ( "called write(% d, \"hi geeks\\n\", %d)."

" It returned %d\n" , fd, strlen ( "how-do-you-do geeks\n" ), sz);

close(fd);

}

Output:

chosen write(three, "hello geeks\n", 12).  it returned 11

Here, when yous see in the file foo.txt after running the code, you become a "hi geeks". If foo.txt file already take some content in it and so write system call overwrite the content and all previous content are deleted and only "hullo geeks" content volition have in the file.

Impress "hello world" from the program without employ any printf or cout function.

C

#include<stdio.h>

#include<string.h>

#include<unistd.h>

#include<fcntl.h>

int main ( void )

{

int fd[2];

char buf1[12] = "hello earth" ;

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[ane]);

return 0;

}

Output:

hello globe

In this lawmaking, buf1 array'south string "hello earth" is first write in to stdin fd[0] then subsequently 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 by Kadam Patel. If you like GeeksforGeeks and would like to contribute, you can too write an article using write.geeksforgeeks.org or mail your article to review-squad@geeksforgeeks.org. See your commodity appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you lot find anything incorrect, or you want to share more information nigh the topic discussed above.

sissonhaves1955.blogspot.com

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

Share this post