If you’re like me, you’re probably more familiar with the concept of pipes at the command prompt than in a programming environment. Or maybe you don’t care either way. Regardless, both types of pipe are similar forms of communications, but programming pipes seem specifically weird to me.
\n
\nBefore crawling into it, be aware that the programming pipe covered in this Lesson is a POSIX thing: Unix, Linux, and macOS. Windows implements pipe programming differently, more akin to server programming. This aspect of pipe programming isn’t covered here.<\/p>\n
All major operating systems do support the command line pipe, the The grep<\/em> command’s output is redirected — or piped — into the less<\/em> command as input. The output stream is diverted from standard output and provided as input. In fact, if you think of I\/O as a stream of water, the pipe concept might begin to make sense.<\/p>\n Pipes in C programming work kinda sorta like pipes at the command prompt. What a pipe does is to create a pair of file descriptors, one for input and another for output. These file descriptors aren’t connected to any file or I\/O device; they stand alone, but are connected with each other: One file descriptor handles input, which is sent to the second file descriptor as output.<\/p>\n Here is the man<\/em> page (2) format for the pipe()<\/em> function:<\/p>\n The sole argument is an integer array containing two elements. Upon success, the function returns zero. Array element Upon failure, the pipe()<\/em> function returns -1, with the errno variable<\/a> set accordingly.<\/p>\n The pipe()<\/em> function is prototyped in the One it’s created, you use file I\/O commands to send and retrieve data to and from the pipe. The following code demonstrates how this communications takes place.<\/p>\n The pipe()<\/em> function is called at Line 22. Its argument is int<\/em> array At Line 30, the write()<\/em> function writes to the pipe’s At Line 33, data is read from the pipe’s The programming pipe’s I\/O takes place as a low-level; it’s not streaming I\/O. Therefore, the low-level functions read()<\/em> and write() are used instead of fread()<\/em> and fwrite()<\/em> or the other high-level file I\/O functions.<\/p>\n In next week’s Lesson<\/a>, I show how to use a pipe to communicate with a thread.<\/p>\n","protected":false},"excerpt":{"rendered":" Pipes are true weirdos in communications programming. Continue reading |<\/code> operator, which flows the output from one program into the input for another:<\/p>\ngrep \"something\" *.txt | less<\/code><\/p>\nint pipe(int fildes[2]);<\/code><\/p>\nfiledes[0]<\/code> is opened for reading and filedes[1]<\/code> is used for writing. The element order and numbers parallel the standard I\/O file descriptors, where stdin<\/em> is assigned to zero and stdout<\/em> is assigned to one.<\/p>\nunistd.h<\/code> header file.<\/p>\n2022_06_25-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <unistd.h>\r\n#include <string.h>\r\n\r\n#define FD_WRITE 1\r\n#define FD_READ 0\r\n\r\nint main()\r\n{\r\n const int size = 32;\r\n int x,r;\r\n int fp[2];\r\n const char *text = \"This is a test\";\r\n char buffer[size];\r\n\r\n \/* initialize the buffer *\/<\/span>\r\n for( x=0; x<size; x++ )\r\n buffer[x] = 0;\r\n\r\n \/* create the pipe *\/<\/span>\r\n r = pipe(fp);\r\n if( r==-1 )\r\n {\r\n perror(\"Pipe\");\r\n exit(1);\r\n }\r\n\r\n \/* write to the pipe *\/<\/span>\r\n r = write(fp[FD_WRITE], text, strlen(text) );\r\n printf(\"Wrote '%s', %d bytes\\n\",text,r);\r\n \/* read from the pipe *\/<\/span>\r\n r = read(fp[FD_READ], buffer, size );\r\n printf(\"Read '%s', %d bytes\\n\",buffer,r);\r\n\r\n return(0);\r\n}<\/pre>\nfp[]<\/code>, which holds two elements. Upon success, write and read file descriptors are placed into the array’s elements zero and one. These file descriptors are open and ready for I\/O. At this point, the write()<\/em> and read()<\/em> functions send and fetch data through the pipe.<\/p>\nFD_WRITE<\/code> element, the file descriptor for writing. It’s sent a chunk of text, which is stored internally in the pipe’s I\/O buffer.<\/p>\nFD_READ<\/code> element. The retrieved text is stored in a buffer, which is output at Line 34:<\/p>\nWrote 'This is a test', 14 bytes
\nRead 'This is a test', 14 bytes<\/code><\/p>\n