_pipe

 

Pour obtenir la dernière documentation sur Visual Studio 2017 RC, consultez Documentation Visual Studio 2017 RC.

Crée un canal pour la lecture et l’écriture.

System_CAPS_ICON_important.jpg Important

Cette API ne peut pas être utilisée dans les applications qui s'exécutent dans le 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 à contenir la lecture et d’écriture de descripteurs de fichiers.

psize
Quantité de mémoire à réserver.

textmode
Mode de fichier.

Retourne 0 si l’opération réussit. Retourne -1 pour indiquer une erreur. En cas d’erreur, errno est défini sur une des valeurs suivantes :

  • EMFILE, ce qui signifie que plus aucun descripteur de fichier n’est disponibles.

  • ENFILE, qui indique un débordement de la table de fichiers système.

  • EINVAL, ce qui indique que soit le tableau pfds est un pointeur null ou que la valeur non valide pour textmode a été passé.

Pour plus d’informations sur les autres codes de retour, voir errno, _doserrno, _sys_errlist et _sys_nerr.

Le _pipe fonction crée un canal, qui est un canal d’e/s artificiel utilisé par un programme pour passer des informations à d’autres programmes. Un canal ressemble à un fichier, car il a un pointeur de fichier, un descripteur de fichier ou les deux, et peut être lu ou écrit à l’aide de la bibliothèque Standard d’entrée et de sortie des fonctions. Toutefois, un canal ne représente pas un fichier spécifique ou un périphérique. Au lieu de cela, il représente un stockage temporaire dans la mémoire qui est indépendante de la mémoire du programme et contrôlez entièrement le système d’exploitation.

_pipesemblable à _open mais ouvre le canal pour lire et écrire et retourne deux fichiers descripteurs au lieu d’une. Le programme peut utiliser les deux côtés du canal ou fermez celle qui n’a pas besoin. Par exemple, l’interpréteur de commandes dans Windows crée un canal lorsqu’il exécute une commande comme PROGRAM1 | PROGRAM2.

La norme de descripteur de sortie PROGRAM1 est attaché au descripteur d’écriture de canal. Le descripteur d’entrée standard de PROGRAM2 est attaché au descripteur de lecture de canal. Cela élimine la nécessité de créer des fichiers temporaires pour transmettre les informations à d’autres programmes.

Le _pipe fonction retourne deux descripteurs de fichier pour le canal dans le pfds argument. L’élément pfds[0] contient le descripteur de lecture et de l’élément pfds[1] contient le descripteur d’écriture. Descripteur de fichier de canal est utilisés dans la même façon que les autres descripteurs de fichiers. (L’entrée de bas niveau et les fonctions de sortie _read et _write peuvent lire et écrire sur un canal.) Pour détecter la condition de fin de cycle, recherchez un _read demande qui renvoie la valeur 0 au nombre d’octets lus.

Le psize argument spécifie la quantité de mémoire, en octets, à réserver pour le canal. Le textmode argument spécifie le mode de traduction pour le canal. La constante de manifeste _O_TEXT spécifie une traduction de texte et la constante _O_BINARY spécifie la traduction binaire. (Voir fopen, _wfopen pour obtenir une description des modes texte et binaires.) Si le textmode argument est 0, _pipe utilise le mode de traduction par défaut qui est spécifié par la variable par défaut en mode _fmode.

Programmes multithread, aucun verrouillage n’est effectuée. Les descripteurs de fichiers qui sont retournées sont ouverts récemment et ne doivent pas être référencées par n’importe quel thread jusqu’après la _pipe appel est terminé.

Pour utiliser le _pipe de fonction pour communiquer entre un processus parent et un processus enfant, chaque processus doit avoir uniquement un descripteur ouverts sur le canal. Les descripteurs doivent être opposées : si le parent a un descripteur de lecture ouvert, l’enfant doit être un descripteur d’écriture ouvert. Le moyen le plus simple pour cela consiste à OR (|) le _O_NOINHERIT indicateur avec textmode. Ensuite, utilisez _dup ou _dup2 pour créer une copie pouvant être héritée du descripteur de canal que vous souhaitez passer à l’enfant. Fermer le descripteur d’origine, puis lancer le processus enfant. Au retour de l’appel de la génération dynamique, fermez le descripteur en double dans le processus parent. Pour plus d’informations, consultez l’exemple 2 plus loin dans cet article.

Dans le système d’exploitation Windows, un canal est détruit lorsque tous les descripteurs sont fermées. (Si tous les descripteurs de lecture sur le canal ont été fermées, puis en écrivant dans le canal provoque une erreur.) Tous les lecture et d’écriture sur le canal attente jusqu'à ce qu’il existe suffisamment de données ou de suffisamment d’espace tampon pour terminer la demande d’e/s.

RoutineEn-tête requisEn-tête facultatif
_pipe<io.h><fcntl.h>,1 <errno.h>2</errno.h></fcntl.h>

1 pour _O_BINARY et _O_TEXT définitions.

2 errno définitions.

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Toutes les versions des bibliothèques Runtime C.

  
      // 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 ) );  
  
      }  
   }  
}  

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.  

Il s’agit d’une application de filtre de base. Il génère l’application crt_pipe_beeper après avoir créé un canal qui dirige stdout engendré l’application du filtre. Le filtre supprime les caractères ASCII 7 (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 du 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;  
}  

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...  

Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez Exemples d'appel de plateforme.

Processus de contrôle et d’environnement
_open, _wopen

Afficher: