How to Read a Second Number on a Line in C

Important Terminology

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

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

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

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

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

Read from stdin => read from fd 0 : Whenever we write any graphic symbol from keyboard, information technology read from stdin through fd 0 and save to file named /dev/tty.
Write to stdout => write to fd 1 : Whenever nosotros come across any output to the video screen, it's from the file named /dev/tty and written to stdout in screen through fd 1.
Write to stderr => write to fd 2 : We run across whatever error to the video screen, it is also from that file write to stderr in screen through fd 2.

I/O System calls

Basically at that place are full 5 types of I/O arrangement calls:

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

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

Parameter:

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

Returns:

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

How it work in OS

• Create new empty file on deejay
• Create file table entry
• Set first unused file descriptor to indicate to file table entry
• Return file descriptor used, -1 upon failure

2. open up: 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 mode ]);        

Parameters

• Path: path to file which you want to use
  • use absolute path begin with "/", when you are not work in aforementioned directory of file.
  • Employ relative path which is only file proper noun with extension, when you are work in same directory of file.
• flags : How you lot like to use
  • O_RDONLY: read but, O_WRONLY: write only, O_RDWR: read and write, O_CREAT: create file if it doesn't exist, O_EXCL: forbid creation if it already exists

How information technology works in OS

• Find the existing file on disk
• Create file table entry
• Set first unused file descriptor to point to file tabular array entry
• Render file descriptor used, -i 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/n" , fd);

if (fd ==-1)

{

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

perror ( "Plan" );

}

return 0;

}

Output:

fd = 3

3. shut: Tells the operating system you are washed with a file descriptor and Shut the file which pointed by fd.

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

Parameter:

• fd :file descriptor

Return:

• 0 on success.
• -1 on error.

How it works in the Bone

• Destroy file table entry referenced by element fd of file descriptor table
  – 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 main()

{

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

if (fd1 < 0)

{

perror ( "c1" );

leave (i);

}

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

if (close(fd1) < 0)

{

perror ( "c1" );

exit (1);

}

printf ( "airtight the fd.\n" );

}

Output:

opened the fd = 3 closed the fd.

C

#include<stdio.h>

#include<fcntl.h>

int main()

{

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

close(fd1);

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

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

exit (0);

}

Output:

fd2 = iii

Here, In this code start open() returns 3 because when main procedure created, then fd 0, 1, 2 are already taken by stdin, stdout and stderr. And so first unused file descriptor is three in file descriptor table. After that in shut() system call is gratis it this 3 file descriptor and so afterward set three file descriptor as null. So when nosotros chosen second open(), then offset unused fd is also 3. Then, output of this programme is iii.

4. read: From the file indicated past the file descriptor fd, the read() function reads cnt bytes of input into the memory 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 finish of file
• render -1 on error
• return -1 on point interrupt

Important points

• buf needs to betoken to a valid memory location with length not smaller than the specified size because of overflow.
• fd should be a valid file descriptor returned from open() to perform read operation because if fd is Zilch then read should generate mistake.
• cnt is the requested number of bytes read, while the return value is the actual number of bytes read. Besides, some times read system telephone 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" ); exit (1); }

sz = read(fd, c, 10);

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

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

c[sz] = '\0' ;

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

}

Output:

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

Suppose that foobar.txt consists of the half-dozen ASCII characters "foobar". Then what is the output of the following programme?

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 up( "sample.txt" , O_RDONLY, 0);

read(fd1, &c, 1);

read(fd2, &c, 1);

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

leave (0);

}

Output:

c = f

The descriptors fd1 and fd2 each have their own open file tabular array entry, and then each descriptor has its ain 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 be greater than INT_MAX (defined in the limits.h header file). If cnt is aught, write() simply returns 0 without attempting whatsoever 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
• render 0 on reaching terminate of file
• return -i on error
• return -1 on signal interrupt

Of import points

• The file needs to be opened for write operations
• buf needs to be at to the lowest degree every bit long as specified by cnt because if buf size less than the cnt then buf volition pb to the overflow condition.
• 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 point, the event is ane of the following:
  -If write() has not written any information nevertheless, it returns -1 and sets errno to EINTR.
  -If write() has successfully written some data, it returns the number of bytes it wrote earlier it 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 (ane);

}

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

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

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

close(fd);

}

Output:

called write(three, "hello geeks\n", 12).  it returned eleven

Here, when you see in the file foo.txt after running the lawmaking, you get a "hello geeks". If foo.txt file already take some content in it then write organization telephone call overwrite the content and all previous content are deleted and simply "hello geeks" content will accept in the file.

Impress "hi world" from the program without use whatever printf or cout function.

C

#include<stdio.h>

#include<string.h>

#include<unistd.h>

#include<fcntl.h>

int principal ( void )

{

int fd[two];

char buf1[12] = "hello globe" ;

char buf2[12];

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

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

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

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

close(fd[0]);

close(fd[ane]);

return 0;

}

Output:

howdy globe

In this code, buf1 assortment'southward string "how-do-you-do world" is beginning write in to stdin fd[0] then after that this string write into stdin to buf2 array. Later that write into buf2 assortment to the stdout and print output " how-do-you-do world ".
This article is contributed past Kadam Patel. If you like GeeksforGeeks and would like to contribute, you lot tin can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks chief page and assist other Geeks.
Please write comments if you detect anything incorrect, or you want to share more information virtually the topic discussed above.

gilchristmankis.blogspot.com

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

Share this post