管道linuxc

A. 用linux C命名管道实现进程间通信的题目，已写出代码，但有一个神奇的小问题，open路径正确却有时失败

通常管道创建的时候会出现创建不成功的情况，要在管道创建的时候就进行异常处理，如果创建不成功就重新创建，这个错误是找不到管道文件

B. Linux C,有名管道写端每1秒写入一次数据，读端每5秒读出一次数据。读端为什么每次只能读出最新的数据，

01 #includestdio.h02 #includeunistd.h0304 int main()05 {06 int n,fd[2]; // 这里的 fd 是文件描述符的数组，用于创建管道做准备的07 pid_t pid;08 char line[100];09 if(pipe(fd)0) // 创建管道10 printf("pipe create error\n");1112 if((pid=fork())0) //利用 fork()创建新进程13 printf("fork error\n");1415 else if(pid0){ //这里是父进程，先关闭管道的读出端，然后在管道的写端写入“hello world"16 close(fd[0]);17 write(fd[1],"hello word\n",11);18 }19 else{20 close(fd[1]); //这里是子进程，先关闭管道的写入端，然后在管道的读出端读出数据21 n= read(fd[0],line,100);22 write(STDOUT_FILENO,line,n);23 }24 exit(0);25 }

如果浏览器不支持 cookie 该怎么办？
如果您的应用程序涉及不支持 cookie 的浏览器，您就不得不采取其他方法在应用程序中从一张页面向另一张页面传递信息。一种方式是从表单传递数据（有关表单和用户输入的内容，稍早前我们已经在本教程中介绍过了）。
下面的表单在用户单击提交按钮时向 "welcome.php" 提交了用户输入：Name:Age:

C. 在linux下可以用命名管道实现c程序与qt的数据通信吗

当然可以了。不过可以直接使用dbus进行进程间通讯，C程序发送数据（libdbus），Qt去捕获信号(QDbus)，这样来的更方便点，否则你要自己封装管道的收发接口。

D. Linux C: 1、启动A进程，创建一有名管道，并向其写入一些数据 2、启动B进程，从A创建的有名管道中读出数据

01 #include<stdio.h>
02 #include<unistd.h>
03
04 int main()
05 {
06 int n,fd[2]; // 这里的 fd 是文件描述符的数组，用于创建管道做准备的
07 pid_t pid;
08 char line[100];
09 if(pipe(fd)<0) // 创建管道
10 printf("pipe create error\n");
11
12 if((pid=fork())<0) //利用 fork()创建新进程
13 printf("fork error\n");
14
15 else if(pid>0){ //这里是父进程，先关闭管道的读出端，然后在管道的写端写入“hello world"
16 close(fd[0]);
17 write(fd[1],"hello word\n",11);
18 }
19 else{
20 close(fd[1]); //这里是子进程，先关闭管道的写入端，然后在管道的读出端读出数据
21 n= read(fd[0],line,100);
22 write(STDOUT_FILENO,line,n);
23 }
24 exit(0);
25 }

E. linux c语言 管道pipe的问题

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(int argc, const char *argv[])
{
int fd[2];
int pid;

if (argc != 2)
{
printf("Usage:\n\t%s string\n", argv[0]);
return 1;
}

if (pipe(fd) < 0)
{
printf("Unable to create pipe!\n");
return 1;
}

// fork child process
pid = fork();

if (pid == 0) //child
{
close(fd[0]); //close read end
write(fd[1], argv[1], strlen(argv[1])); //write message
close(fd[1]); //close before exit
}
else if (pid > 0) //parent
{
char buf[1024];
int len;

close(fd[1]); //close write end
len = read(fd[0], buf, sizeof(buf)); //read from the pipe
buf[len] ='\0';
printf("<PARENT> message from child: %s\n", buf);
wait(NULL); //wait for child exit
close(fd[0]); //close before exit
}
else
{
printf("Unable to fork!\n");
return 1;
}

return 0;
}

F. linux下c语言pipe无名管道 main函数创建两个进程p1和p2，p1把一个文件名通过管道给main进程，main进程打开

#include <stdio.h>
main()
{
int i,r,p1,p2,fd[2];
char buf[50],s[50];
pipe(fd); //创建匿名管道，fd[0]为读端，fd[1]为写端
while((p1=fork())==-1); //创建子进程P1，直至成功为止（p1!=-1）
if(p1==0) //子进程P1执行逻辑
{
lockf(fd[1],1,0); //锁定管道写端，保证写入数据的完整性
sprintf(buf,"child process P1 is sending messages!\n"); //在buf中填入准备写入管道的信息数据
printf("child processP1!\n"); //打印“子进程P1正在运行”
write(fd[1],buf,50); //向管道写端fd[1]写入buf中的数据，写完后该数据即可以从读端fd[0]读出
sleep(5); //睡眠5秒
lockf(fd[1],0,0); //解锁管道写端
exit(0); //子进程P1退出
}
else //主进程的执行逻辑
{
while((p2=fork())==-1); //创建第二个子进程P2
if(p2==0) //子进程P2的执行逻辑
{
lockf(fd[1],1,0); //锁定管道写端，保证数据写入完整
sprintf(buf,"child process P2 is sending messages!\n"); //在buf中填入准备写入管道的信息数据
printf("child processP2!\n"); //打印“子进程P2正在运行”
write(fd[1],buf,50); //向管道写端fd[1]写入buf中的数据，写完后该数据即可从读端fd[0]读出
sleep(5); //睡眠5秒
lockf(fd[1],0,0); //解锁管道写端
exit(0); //子进程P2退出
}
//以下为主进程执行逻辑
wait(0); //等待某个子进程退出
if(r=read(fd[0],s,50)==-1) //从管道读端fd[0]读取P1或者P2写入的数据（视哪个子进程抢先执行到lockf函数）
{
printf(:can't read pipe\n"); //读取失败，打印错误信息
}
else
{
printf(:%s\n",s); //打印出读到的信息数据
}
wait(0); //等待第二个子进程退出
if(r=read(fd[0],s,50)==-1) //从管道读端fd[0]读取出P1或者P2写入的数据（视哪个子进程后执行到lockf函数）
{
printf(:can't read pipe\n"); //读取失败，打印错误信息
}
else
{
printf(:%s\n",s); //打印读取到的信息数据
}
exit(0); //主进程退出
}
}

总的说来，就是主进程创建了两个子进程P1、P2，这两个子进程分别向管道写入了一行文字，然后主进程从管道另一端将这两行文字读出并打印出来
由于进程的并发执行性，哪个子进程的信息先写到管道是随机的，因此该程序每次运行的输出可能并不相同，两行文字之间可能会相互交换

G. Linux用C语言怎么将telnet反馈的结果写入管道

将标准输出重定向到管道写端

H. linux下C进程之间管道通信的问题，懂的进来看下这段程序怎么运行起来不对

你的要求 “管道尾写个数据后，管道头读，然后在让管道尾写，一直循环”，其实是一个进程同步的问题，即一边写完了，另外一边读，读完了，才能再写。所以要用到进程间通信的方式来让读段通知写端我已经读完了，你可以写下一个了。 有很多种方法来实现这个进程同步，比如用信号量等。不过既然你是一个管道的代码，我就用了管道的方式来实现，让你参考。下面的代码创建了两个管道，pipe_a2b 这个就是你原来的那个管道， pipe_b2a 这个是新加的，用来让读端通知写端可以继续的。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

int main()
{
char r_buf[10];
char w_buf[10];
pid_t pid;
int pipe_a2b[2]; /* parent write, child read */
int pipe_b2a[2]; /* child write, parent read */
memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_a2b)<0)
{
printf("creat pipe error\n");
exit(1);
}
if(pipe(pipe_b2a)<0)
{
printf("creat pipe error\n");
exit(1);
}

pid=fork();

if (pid == 0)
{
/* child, reader */
close(pipe_a2b[1]);
close(pipe_b2a[0]);
while(1)
{
read(pipe_a2b[0],r_buf,10);
printf("FIFO :%s\n",r_buf);
write(pipe_b2a[1], "c", 1); /* tells parent continue */
}
close(pipe_a2b[0]);
close(pipe_b2a[1]);
}

if(pid>0)
{
/* parent, writer */
close(pipe_a2b[0]);
close(pipe_b2a[1]);
while(1)
{
printf("please input w_buf:\n");
scanf("%s",w_buf);
write(pipe_a2b[1],w_buf,strlen(w_buf));

/* wait for the "c" from child to continue to next write */
read(pipe_b2a[0], r_buf, 10);
}
close(pipe_a2b[1]);
close(pipe_b2a[0]);
}

exit(0);
}

I. linux下C语言编程，管道，p，fork，疑问的是，为什么连用那么多close必须要close 代码如下

文件描述符0,1,2分别表示标准输入标准输出,标准错误输出, 所以在子进程里close(1)是关闭了标准输出, 然后用p(fda[1]);此时未用的最小文件描述符就是1(被关闭);这里关闭fda[0]就是为了说明在子进程是管道的写端(fda[0],不关闭是可以的为了保险起见关闭).然后子进程退出会调用系统程序ls,于是当前的文件目录就被发送到管道中.父进程同理, 就是将标准输出作为管道的读端,它读到的是子进程ls后的内容,对文件计数,

J. Linux C 通过管道实现文件复制

#include"stdio.h"
#include"stdlib.h"
#include"unistd.h"
#include"sys/types.h"
#include"sys/stat.h"
#include"string.h"
#include"fcntl.h"
#include"errno.h"

#define FIFO1 "/tmp/fifo"
#define MAXLINE 100

void client1(int);
void client2(int);

int main(int argc,char **argv)
{
int writefd;
writefd=open(FIFO1,O_WRONLY,0);
client1(writefd);
client2(writefd);

close(writefd);
unlink(FIFO1);
exit(0);
}

void client1(int writefd1)//实现从文件写到管道，自己创建一个aa.txt文件
{
char buff[MAXLINE];
int fd;
memset(buff,0,sizeof(buff));
fd=open("aa.txt",O_CREAT|O_RDWR,S_IRWXU);
read(fd,buff,sizeof(buff));
write(writefd1,buff,sizeof(buff));
close(fd);
}
void client2(int writefd2)//)//实现从管道写到另一个文件
{
char buff[MAXLINE];
int fd;
fd=open("bb.txt",O_CREAT|O_RDWR,S_IRWXU);
read(writefd2,buff,sizeof(buff));
write(fd,buff,sizeof(buff));
close(fd);

}

我这里省略了许多判断，自己加哈
如有问题，在线交流