In the realm of C programming, managing input, output, and memory effectively is fundamental. To help you grasp these critical concepts, get_next_line is a project where you'll write a function that reads a file line by line using a file descriptor. Each invocation of the function reads the next line from the file, allowing you to process the entire file content one line at a time.
A file descriptor is a non-negative integer that uniquely identifies an open file in a system. When a program opens a file, the operating system returns a file descriptor that can be used to refer to that file in subsequent operations, such as reading, writing, or closing the file. File descriptors are an abstraction used by the operating system to manage various I/O resources, including files, sockets, and pipes.
0, 1, and 2 (standard input, standard output, and standard error) in Process A are independent and separate from the file descriptors in Process B. This isolation ensures that file operations in one process do not interfere with those in another.
Each file descriptor is associated with a file descriptor table entry that contains essential information about the file. This includes the file path, access permissions, and the current offset, which tracks the position within the file for read/write operations. This structure allows the operating system to manage multiple open files efficiently and ensure correct access and data manipulation.
Note that file descriptors 0, 1, and 2 are reserved by the operating system for standard streams. File descriptor 0 is used for standard input (stdin), which typically represents input from the keyboard. File descriptor 1 is used for standard output (stdout), which represents output to the screen or terminal. File descriptor 2 is used for standard error (stderr), which also represents output to the screen or terminal but is specifically intended for error messages. These reserved file descriptors ensure that basic input and output operations can be consistently managed across different programs and environments. Any file descriptor returned by the open function will be 3 or higher, ensuring it does not conflict with these standard streams.
<p>'#include <fcntl.h>'<br>
'#include <unistd.h>'</p>
<p>int fd = open("example.txt", O_RDONLY);<br>
if (fd == -1) {<br>
perror("Error opening file");<br>
return 1;<br>
}</p>
A file descriptor, represented as an integer, is obtained using the open function, which takes two parameters: the file name (or path) and flags that determine the file's access permissions. For example, to read a file's content, we use the O_RDONLY flag (read-only). To read and write, we use the O_RDWR flag. While there are many flags available, we will use only O_RDONLY for this project. The open function returns a non-negative integer, which is the file descriptor if the operation is successful; otherwise, it returns -1 to indicate an error (you don't have permission to access example.txt). Note that the open function is in the unistd.h library, and the permission flags are defined in fcntl.h.
<p>'#include <fcntl.h>'<br>
'#include <unistd.h>'<br>
'#include <stdio.h>'<br>
'#define BUFFER_SIZE 4'</p>
<p>int fd = open("example.txt", O_RDONLY);<br>
if (fd == -1) {<br>
perror("Error opening file");<br>
return 1;<br>
}<br>
char buffer[BUFFER_SIZE];<br>
read(fd, buffer, sizeof(buffer)-1);<br>
printf("1st call : %s\n", buffer);<br>
// prints the first 3 bytes<br>
read(fd, buffer, sizeof(buffer)-1);<br>
printf("2nd call : %s\n", buffer);<br>
read(fd, buffer, sizeof(buffer)-1);<br>
printf("3rd call : %s\n", buffer);<br>
read(fd, buffer, sizeof(buffer)-1);<br>
printf("4th call : %s\n", buffer);<br>
read(fd, buffer, sizeof(buffer)-1);<br>
printf("5th call : %s\n", buffer);</p>
code result
1st call : HEL
2nd call : LO
3rd call : WOR
4th call : LD
5th call : (null)
The read function, provided by the unistd.h library, is used to read data from a file descriptor. It takes three parameters: the file descriptor, a buffer to store the read data, and the number of bytes to read from the file, read function returns the number of bytes read from the file.
In the file descriptor table, there's an attribute called offset. The offset keeps track of the current position within the file. Every time the read function is called, it reads data starting from the current offset and then advances the offset by the number of bytes read. This ensures that subsequent reads continue from where the last read left off.
In our example:
The second call to read reads the next 3 bytes starting from the updated offset (3), then updates the offset to 6.
etc ...
5th call to read buffer will be null and read returns 0 indicating end of file.
此过程将持续进行，直到从文件中读取所有数据或发生错误。每次读取后缓冲区都以 null 终止，以确保它可以作为字符串打印。
char *get_next_line(int fd) 将文件的文件描述符作为参数，并为每次调用返回一行。如果到达文件末尾，则返回 NULL。
https://github.com/Its-JoeTheKing/get_next_line
以上是获取下一行学习如何处理文件描述符和系统 I/O 的项目的详细内容。更多信息请关注PHP中文网其他相关文章！
