_pipe
Cria um pipe para leitura e gravação.
int _pipe(
int *pfds,
unsigned int psize,
int textmode
);
Parâmetros
pfds[2]
Matriz para conter ler e escrever os descritores de arquivo.psize
Quantidade de memória para reservar.TextMode
Modo de arquivo.
Valor de retorno
Retorna 0 se obtiver êxito.Retorna – 1 para indicar um erro, no qual caso errno é definido como um dos três valores: EMFILE, que indica que não há mais descritores de arquivo disponível; ENFILE, que indica um estouro de tabela do sistema de arquivo; ou EINVAL, que indica que qualquer matriz pfds era um ponteiro nulo ou um valor inválido para TextMode foi passada.
Para obter mais informações sobre esses e outros códigos de retorno, consulte _doserrno, errno, _sys_errlist e _sys_nerr.
Comentários
The _pipe função cria um pipe. A pipe é um canal de E/S artificial que usa um programa para passar informações para outros programas.Um pipe é semelhante a um arquivo em que ele tem um ponteiro de arquivo, um descritor de arquivo ou ambos e pode ser lido ou gravado usando a biblioteca padrão de entrada do e funções de saída.No entanto, um pipe não representa um arquivo específico ou dispositivo.Em vez disso, ele representa o armazenamento temporário na memória que é independente da memória do programa e controlada inteiramente pelo sistema operacional.
_pipe é semelhante a _open mas abre o pipe para leitura e gravação, retornando o dois de descritores em vez de um arquivo. O programa pode usar ambos os lados da conexão ou que ele não precisa fechar.Por exemplo, o processador de comandos no Windows NT cria um pipe ao executar um comando sistema autônomo:
PROGRAM1 | PROGRAM2
O padrão de saída descritor de PROGRAM1 é anexado ao descritor de gravar do pipe. O descritor de entrada padrão de PROGRAM2 é anexado ao descritor de leitura do pipe. Isso elimina a necessidade de criar arquivos temporários para passar informações para outros programas.
The _pipe função retorna dois descritores de arquivo para o pipe na pfds argumento. O elemento pfds[0] contém o descritor de leitura e o elemento pfds[1] contém o descritor de gravar. Descritores de arquivo de pipe são usados da mesma forma que outros descritores de arquivo.(A entrada de nível inferior e a saída funciona _read e _write possa ler e gravar em um pipe.) Para detectar a condição de extremidade de pipe, procure um _read solicitação retorna 0 sistema autônomo o número de bytes lidos.
The psize argumento especifica a quantidade de memória, em bytes para reservar para o pipe.The TextMode argumento especifica o modo de tradução para o pipe.A constante de manifesto _O_TEXT Especifica uma tradução do texto e a constante _O_BINARY Especifica a conversão binário. (See fopen para obter uma descrição dos modos texto e binário.) Se o TextMode argumento for 0, _pipe usa o modo de tradução padrão especificado pela variável de modo padrão _fmode.
Os programas multithread, nenhum bloqueio é executado.O arquivo descritores retornados são abertos recentemente e não devem ser referenciados por qualquer segmento até que o _pipe telefonar é concluída.
Para usar o _pipe função para se comunicar entre pai e um processo filho, cada processo deve ter apenas um descritor abertas no pipe. Os descritores de devem ser opposites: Se o pai possui um descritor de leitura em aberto, e, em seguida, o filho deve ter um descritor de gravar em em aberto.A maneira mais fácil de fazer isso é OR (|) the _O_NOINHERIT sinalizar com TextMode.Em seguida, use _dup ou _dup2 Para criar uma cópia do descritor de pipe herdável que você deseja passar para o filho. fechar o descritor de original e gerar processo filho.No retorno de telefonar proliferar, fechar o descritor de duplicados no processo pai.Para obter mais informações, consulte Exemplo 2 abaixo.
No sistema operacional Windows, um pipe é destruído quando todos os seus descritores foram fechados.(Se todos os descritores de leitura no pipe tem sido fechados, a gravação no pipe causa um erro.) Todas as operações de leitura e gravar em espera pipe até que haja suficiente dados ou espaço do buffer suficiente para concluir a solicitação de E/s.
Requisitos
Rotina |
Cabeçalho necessário |
Cabeçalho opcional |
|---|---|---|
_pipe |
<io.h> |
<fcntl.h>, 1 <errno.h> 2 |
1 De _O_BINARY e _O_TEXT definições.
2 errno definições.
Para obter mais informações de compatibilidade, consulte Compatibilidade na introdução.
Bibliotecas
Todas as versões do C em time de execução bibliotecas.
Exemplo 1
// crt_pipe.c
/* This program uses the _pipe function to pass streams of
* text to spawned processes.
*/
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <process.h>
#include <math.h>
enum PIPES { READ, WRITE }; /* Constants 0 and 1 for READ and WRITE */
#define NUMPROBLEM 8
int main( int argc, char *argv[] )
{
int fdpipe[2];
char hstr[20];
int pid, problem, c;
int termstat;
/* If no arguments, this is the spawning process */
if( argc == 1 )
{
setvbuf( stdout, NULL, _IONBF, 0 );
/* Open a set of pipes */
if( _pipe( fdpipe, 256, O_BINARY ) == -1 )
exit( 1 );
/* Convert pipe read descriptor to string and pass as argument
* to spawned program. Program spawns itself (argv[0]).
*/
_itoa_s( fdpipe[READ], hstr, sizeof(hstr), 10 );
if( ( pid = _spawnl( P_NOWAIT, argv[0], argv[0],
hstr, NULL ) ) == -1 )
printf( "Spawn failed" );
/* Put problem in write pipe. Since spawned program is
* running simultaneously, first solutions may be done
* before last problem is given.
*/
for( problem = 1000; problem <= NUMPROBLEM * 1000; problem += 1000)
{
printf( "Son, what is the square root of %d?\n", problem );
_write( fdpipe[WRITE], (char *)&problem, sizeof( int ) );
}
/* Wait until spawned program is done processing. */
_cwait( &termstat, pid, WAIT_CHILD );
if( termstat & 0x0 )
printf( "Child failed\n" );
_close( fdpipe[READ] );
_close( fdpipe[WRITE] );
}
/* If there is an argument, this must be the spawned process. */
else
{
/* Convert passed string descriptor to integer descriptor. */
fdpipe[READ] = atoi( argv[1] );
/* Read problem from pipe and calculate solution. */
for( c = 0; c < NUMPROBLEM; c++ )
{
_read( fdpipe[READ], (char *)&problem, sizeof( int ) );
printf( "Dad, the square root of %d is %3.2f.\n",
problem, sqrt( ( double )problem ) );
}
}
}
Saída de exemplo
Son, what is the square root of 1000?
Son, what is the square root of 2000?
Son, what iDad, the square root of 1000 is 31.62.
Dad, the square root of 2000 is 44.72.
s the square root of 3000?
Dad, the square root of 3000 is 54.77.
Son, what is the square root of 4000?
Dad, the square root of 4000 is 63.25.
Son, what is the square root of 5000?
Dad, the square root of 5000 is 70.71.
Son, what is the square root of 6000?
SonDad, the square root of 6000 is 77.46.
, what is the square root of 7000?
Dad, the square root of 7000 is 83.67.
Son, what is the square root of 8000?
Dad, the square root of 8000 is 89.44.
Exemplo 2
Este é um aplicativo de filtro simples.Ele gera crt_pipe_beeper aplicativo após a criação de um pipe direciona stdout do aplicativo gerado ao filtro.O filtro remove caracteres ASCII de 7 (alarme sonoro).
// crt_pipe_beeper.c
#include <stdio.h>
#include <string.h>
int main()
{
int i;
for(i=0;i<10;++i)
{
printf("This is speaker beep number %d...\n\7", i+1);
}
return 0;
}
O aplicativo de filtro real:
// crt_pipe_BeepFilter.C
// arguments: crt_pipe_beeper.exe
#include <windows.h>
#include <process.h>
#include <memory.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#define OUT_BUFF_SIZE 512
#define READ_FD 0
#define WRITE_FD 1
#define BEEP_CHAR 7
char szBuffer[OUT_BUFF_SIZE];
int Filter(char* szBuff, ULONG nSize, int nChar)
{
char* szPos = szBuff + nSize -1;
char* szEnd = szPos;
int nRet = nSize;
while (szPos > szBuff)
{
if (*szPos == nChar)
{
memmove(szPos, szPos+1, szEnd - szPos);
--nRet;
}
--szPos;
}
return nRet;
}
int main(int argc, char** argv)
{
int nExitCode = STILL_ACTIVE;
if (argc >= 2)
{
HANDLE hProcess;
int fdStdOut;
int fdStdOutPipe[2];
// Create the pipe
if(_pipe(fdStdOutPipe, 512, O_NOINHERIT) == -1)
return 1;
// Duplicate stdout file descriptor (next line will close original)
fdStdOut = _dup(_fileno(stdout));
// Duplicate write end of pipe to stdout file descriptor
if(_dup2(fdStdOutPipe[WRITE_FD], _fileno(stdout)) != 0)
return 2;
// Close original write end of pipe
_close(fdStdOutPipe[WRITE_FD]);
// Spawn process
hProcess = (HANDLE)_spawnvp(P_NOWAIT, argv[1],
(const char* const*)&argv[1]);
// Duplicate copy of original stdout back into stdout
if(_dup2(fdStdOut, _fileno(stdout)) != 0)
return 3;
// Close duplicate copy of original stdout
_close(fdStdOut);
if(hProcess)
{
int nOutRead;
while (nExitCode == STILL_ACTIVE)
{
nOutRead = _read(fdStdOutPipe[READ_FD],
szBuffer, OUT_BUFF_SIZE);
if(nOutRead)
{
nOutRead = Filter(szBuffer, nOutRead, BEEP_CHAR);
fwrite(szBuffer, 1, nOutRead, stdout);
}
if(!GetExitCodeProcess(hProcess,(unsigned long*)&nExitCode))
return 4;
}
}
}
return nExitCode;
}
Saída
This is speaker beep number 1...
This is speaker beep number 2...
This is speaker beep number 3...
This is speaker beep number 4...
This is speaker beep number 5...
This is speaker beep number 6...
This is speaker beep number 7...
This is speaker beep number 8...
This is speaker beep number 9...
This is speaker beep number 10...
Equivalente do NET Framework
Não aplicável. Para telefonar a função C padrão, use PInvoke. Para obter mais informações, consulte Exemplos de invocação de plataforma.