_pipe
Crée un canal pour lire et écrire.
Important
Cette API ne peut pas être utilisée dans les applications qui s'exécutent dans Windows Runtime.Pour plus d'informations, consultez Fonctions CRT non prises en charge avec /ZW.
int _pipe( int *pfds, unsigned int psize, int textmode );
Paramètres
pfds[2]
Tableau pour contenir les modèles de fichier en lecture et en écriture.psize
Quantité de mémoire à la réserve.textmode
Mode d'accès au fichier.
Valeur de retour
Retourne 0 si l'opération a réussi.Retourne à 1 pour indiquer une erreur.Sur l'erreur, errno a une de ces valeurs :
EMFILE, ce qui indique que plusieurs modèles de fichier ne sont disponibles.
ENFILE, qui indique un dépassement de capacité de système-fichier-tableau.
EINVAL, ce qui indique que le tableau pfds est un pointeur null ou qu'une valeur non valide pour textmode a été passée.
Pour plus d'informations sur ces derniers et d'autres codes de retour, consultez errno, _doserrno, _sys_errlist, et _sys_nerr.
Notes
La fonction d' _pipe crée un canal, qui est un canal d'E/S artificiel qu'un programme utilise pour passer des informations aux autres programmes.Un canal ressemble à un fichier parce qu'il a un pointeur de fichier, un modèle de fichier, ou les deux, et il peut être lu à partir de ou écrit en utilisant les fonctions d'entrée et de sortie standard de bibliothèque.Toutefois, un canal ne représente pas un fichier spécifique ou un périphérique.À la place, il représente le magasin temporaire dans la mémoire qui est indépendant de la mémoire propre du programme et est contrôlée entièrement par le système d'exploitation.
_pipe ressemble à _open mais ouvre le canal pour lire et écrire et retourne deux modèles de fichier au lieu d'un.Le programme peut utiliser les deux côtés du canal ou fermer celui dont il n'a pas besoin.Par exemple, l'interpréteur de commandes dans les fenêtres crée un canal lorsqu'il exécute une commande telle qu' PROGRAM1 | PROGRAM2.
Le modèle de sortie standard d' PROGRAM1 est attaché au modèle de l'écriture du canal.Le modèle d'entrée standard d' PROGRAM2 est attaché au modèle lecture du canal.Cela élimine le besoin de créer des fichiers temporaires pour passer des informations aux autres programmes.
La fonction d' _pipe retourne deux modèles de fichier dans le canal dans l'argument d' pfds .L'élément pfds[0] contient le modèle lire, et l'élément pfds[1] contient le modèle d'écriture.Les modèles de fichier de canal sont utilisés de la même façon que d'autres modèles de fichier.(Les fonctions d'entrée et de sortie de bas niveau _read et _write peuvent lire et écrire dans un canal.) Pour détecter l'état en fin du cycle, recherchez une requête d' _read qui retourne 0 comme le nombre d'octets a indiqué.
L'argument d' psize spécifie la quantité de mémoire, en octets, pour réserver du canal.L'argument d' textmode spécifie à l'état de traduction du canal._O_TEXT constante de manifeste spécifie une conversion de texte, et _O_BINARY constante spécifie la traduction binaire.(Consultez le fopen, _wfopen pour une description des modes de texte ou binaire.) Si l'argument d' textmode est 0, _pipe utilise un en mode d'interprétation par défaut spécifié par la variable _fmodede valeur par défaut mode.
Dans les programmes multithread, aucun verrouillage n'est exécuté.Les modèles de fichier qui sont retournés sont récemment ouverts et ne doivent pas être référencés par n'importe quel thread tant que l'appel d' _pipe est terminé.
Pour utiliser la fonction d' _pipe pour communiquer entre un processus parent et un processus enfant, chaque processus doit avoir un seul modèle ouvert sur le canal.Les modèles doivent être des opposúx : si le parent est un modèle lu ouvert, l'enfant doit avoir un modèle d'écriture ouvert.La façon la plus simple consiste à OR (|) la balise d' _O_NOINHERIT avec textmode.Ensuite, utilisez _dup ou _dup2 de créer une copie pouvant être hérité du modèle de canal que vous souhaitez passer à l'enfant.Fermez le modèle d'origine, puis engendrez le processus enfant.Sur le retour de l'appel de frai, fermez le modèle en double dans le processus parent.Pour plus d'informations, consultez l'exemple 2 ultérieurement dans cet article.
Dans le système d'exploitation Windows, un canal est perdu lorsque tous ses modèles ont été fermés.(Si tous lisaient des modèles sur le canal ont été fermés, l'écriture au canal provoque une erreur.) Toutes les opérations en lecture et en écriture sur le canal attendent jusqu'à ce qu'il y ait suffisamment de données ou suffisamment d'espace de mémoire tampon pour remplir la demande d'E/S.
Configuration requise
Routine |
En-tête requis |
En-tête facultatif |
|---|---|---|
_pipe |
<io.h> |
<fcntl.h>, 1 <errno.h>2 |
1 Pour _O_BINARY et des définitions d' _O_TEXT .
2 définitions d' errno .
Pour plus d'informations de compatibilité, consultez Compatibilité.
Bibliothèques
Toutes les versions d' Bibliothèques runtime C.
Exemple 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 ) );
}
}
}
Résultat de l'exemple
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.
Exemple 2
Il s'agit d'une application de base de filtre.Elle engendre le crt_pipe_beeper d'application après qu'elle crée un canal qui dirige le stdout de l'application engendrée au filtre.Le filtre supprime ASCII 7 caractères (signal sonore).
// 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;
}
L'application réelle de filtre :
// 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;
}
Sortie
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...
Équivalent .NET Framework
Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez Exemples d'appel de code non managé.