Mapping UNIX Pipe to C++ std::cout - c++

Question

I am researching options of communicating processes in C++. Started with idea to bind Unix pipe to std::cout, but I could get it work. When writing directly using write(STDOUT_FILENO), I get expected result. When writing using std::cout, I get smaller and random output.
#include <iostream>
#include <unistd.h>
#include <fcntl.h>
const int PIPE_READ = 0;
const int PIPE_WRITE = 1;
int main() {
int pfd[2];
if(pipe(pfd) == -1){
std::cout << "Cannot create pipe" << std::endl;
return 0;
}
int pid = fork();
if(pid == -1){
std::cout << "Error on fork: " << errno << std::endl;
} else if(pid == 0) { // Child process
if(dup2(pfd[PIPE_WRITE],STDOUT_FILENO) < 0) {
std::cout << "Cannot redirect STDOUT: " << errno << std::endl;
return 0;
}
close(pfd[PIPE_WRITE]);
for(int i = 0; i < 8; i++){
int data = i;
write(STDOUT_FILENO,&data,sizeof(int)); // Works
//std::cout << data; // Don't work
}
} else { // Parent process
close(pfd[PIPE_WRITE]);
for(int i = 0; i < 8; i++){
int data;
ssize_t status;
if((status = read(pfd[PIPE_READ],&data,sizeof(int))) != sizeof(int)) {
std::cout << "Error (" << errno << ") on read: " << status << std::endl;
return -1;
}
std::cout << data << std::endl;
}
}
return 0;
}

Answer 1

Lets take a closer look at your writing:
write(STDOUT_FILENO,&data,sizeof(int)); // Works
//std::cout << data; // Don't work
The first "working" version write the contents of data in raw binary form to standard output. The second "non-working" version write the value of data as text to standard output.
If the value of data is 5 then the write call will write the integer value 5 while std::cout << data will write the integer value 53 (using ASCII encoding).
This of course have implications when you read the data as a raw and binary int in the parent.
If you want write the raw binary data to std::cout you have to use std::ostream::write:
std::cout.write(reinterpret_cast<char*>(&data), sizeof data);
The above line is equivalent to the write system-call you have.
Also important to know is that writing an int in raw form will write sizeof(int) bytes, usually four. Writing a single-digit integer as text will write a single byte.
Your loop will write eight numbers, which means it will write 32 bytes (4 * 8) if using write. If you output using << to std::cout then you will write 8 bytes. When you read you will read those 8 bytes and put into two single int values, then the read call will return 0 because the pipe has been closed.
What the values of those two int values will be depends on your hardware architecture, if it's little-endian or big-endian.