Como usar o tubo função na linguagem C

Um tubo é um meio de comunicação entre processos. Um processo grava dados no tubo e outro processo lê os dados do tubo. Neste artigo, veremos como a função Pipe () é usada para implementar o conceito usando a linguagem C.

Sobre tubo

No tubo, os dados são mantidos em uma ordem FIFO, o que significa escrever dados em uma extremidade do tubo sequencialmente e ler dados de outra extremidade do tubo na mesma ordem seqüencial.

Se algum processo lê do tubo, mas nenhum outro processo ainda não escreveu para o tubo, leia retorna o final do arquivo. Se um processo quiser escrever em um tubo, mas não há outro processo conectado ao tubo para leitura, essa é uma condição de erro, e o tubo gera um sinal sigpipe.

Arquivo de cabeçalho

#incluir

Sintaxe

Int Pipe (int arquivado [2])

Argumentos

Esta função exige um único argumento, uma matriz de dois números inteiros (arquivado). Arquiva [0] é usado para ler o tubo e Arquiva [1] é usado para escrever no tubo. O processo que deseja ler do tubo deve fechar Arquiva [1], e o processo que deseja escrever para o tubo deve fechar Arquiva [0]. Se as extremidades desnecessárias do tubo não estiverem explicitamente fechadas, então o final do arquivo (EOF) nunca será devolvido.

Valores de retorno

No sucesso, o cano() Retorna 0, para falha, a função retorna -1.

Pictoralmente, podemos representar o cano() função da seguinte forma:

Abaixo estão alguns exemplos que descrevem como usar a função do tubo na linguagem C.

Exemplo 1

Neste exemplo, veremos como a função do tubo funciona. Embora usar um tubo em um único processo não seja muito útil, mas teremos uma ideia.

// Exemplo 1.c
#incluir
#incluir
#incluir
#incluir
int main ()

int n;
Int arquivou [2];
buffer de char [1025];
char *message = "Olá, mundo!";
tubo (arquivado);
write (arquivado [1], mensagem, strlen (mensagem));
if ((n = leia (arquivado [0], buffer, 1024))> = 0)
buffer [n] = 0; // encerrar a string
printf ("leia %d bytes do tubo:" %s "\ n", n, buffer);

outro
perror ("leitura");
saída (0);

Aqui criamos primeiro um tubo usando cano() função então escrito no tubo usando Fildes [1] fim. Então, os dados foram lidos usando a outra extremidade do tubo, que é Arquiva [0]. Para ler e escrever no arquivo, costumávamos ler() e escrever() funções.

Exemplo2

Neste exemplo, veremos como os processos pai e filho se comunicam usando o tubo.

// Exemplo2.c
#incluir
#incluir
#incluir
#incluir
#incluir
int main ()

Int arquivou [2], nbytes;
pid_t childpid;
char string [] = "Olá, mundo!\ n ";
Char Readbuffer [80];
tubo (arquivado);
if ((childpid = fork ()) == -1)

Perror ("Fork");
saída (1);

if (childpid == 0)

fechar (arquivados [0]); // o processo infantil não precisa deste fim do tubo
/ * Envie "String" através do lado da saída do tubo */
write (arquivado [1], string, (strlen (string) +1));
saída (0);

outro

/ * O processo pai fecha o lado da saída do tubo */
fechar (arquivados [1]); // processo pai não precisa desse fim do tubo
/ * Leia em uma string do tubo */
nbytes = leia (arquivado [0], readbuffer, sizeof (readbuffer));
printf ("Leia String: %s", readbuffer);

retornar (0);

Primeiro, um tubo foi criado usando função de tubo e um processo infantil foi bifurcado. Em seguida, o processo infantil fecha a extremidade de leitura e escreve no tubo. O processo pai fecha a extremidade de gravação e lê do tubo e exibe -o. Aqui o fluxo de dados é apenas uma maneira que é de criança para pai.

Conclusão:

cano() é uma chamada de sistema poderosa no Linux. Neste artigo, vimos apenas fluxo de dados unidirecional, um processo grava e outro processo lê, criando dois tubos que podemos alcançar o fluxo de dados bidirecionais também.