Write something in a process and read it in another - c

Question

I want to write something in process A and read it in process B which is forked by A. But I find that B cannot read the content unless A is terminated. How can I write in process A while read in B without A quitting? My code is as follows.
#include <stdio.h>
#include <unistd.h>
int mypipe[2];
int main(){
FILE* f;
pid_t pid = 0;
int num = 0, temp;
pipe(mypipe);
pid = fork();
if (pid == (pid_t)0){
f = fdopen(mypipe[0], "r");
while (1){
fscanf(f, "%d", &temp);
printf("from child: %d\n", temp);
}
fclose(f);
}
else{
f = fdopen(mypipe[1], "w");
while (1){
scanf("%d", &num);
fprintf(f, "%d\n", num);
//break;
}
fclose(f);
}
return 0;
}

Answer 1

B cannot read the content unless A is terminated
This is because A doesn't actually write something. stdio streams (represented by FILE *) are buffered. You can set the buffering mode using setvbuf(). The stream you open on your pipe with fdopen() will be fully buffered by default, so no actual writes to the pipe occur until the buffer is full.
The easiest solution is to put a call to fflush() in your code anywhere you want writes to occur, e.g. in your code directly after the fprintf():
while (1){
scanf("%d", &num);
fprintf(f, "%d\n", num);
fflush(f);
//break;
}

Answer 2

First of all there are many unnecessary lines in your code. Instead of doing fdopen() you can directly use read() and write() system calls. Secondly fork() system call return 0 to the child and pid of the child process to the parent. Finally parent should wait for child to finish and clear it from memory to stop it becoming zombie.
This is the corrected version of your code works perfectly without break.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
int status; // To get return status of file
// No need of FILE pointer
int mypipe[2]; // No need to make it global
pid_t pid = 0;
int num = 0, temp;
pipe(mypipe); // Create pipe
if((pid = fork()) == 0) // Child block
{
close(mypipe[1]); // Child will close the writing end
while (1)
{
read(mypipe[0],&temp,sizeof(int));
printf("from child: %d\n",temp);
}
exit(0); // Exit the child
}
else // Parent block
{
close(mypipe[0]); // Parent will close the reading end of pipe
while (1)
{
scanf("%d", &num);
write(mypipe[1],&num,sizeof(int));
}
}
// Parent should wait for child
wait(&status);
return 0;
}
Read the system calls man pages
man 2 read, man 2 write etc.