Bonjour :  
je sais utiliser des pipes pour faire des transferts de messages sous forme de chaine de caracteres entre deux processus pere et fils ( avec des tubes sans nom )  
 
Mais voila : je voudrais faire des transfert d'une structure que j'ai defini.  
 
Est ce possible ?  
 
je voudrais faire un transfert de structure comme celle ci :

 
entre un processus fils et pere.
 
voila, merci d'avance si vous avez une réponse

 
Si tu tiens au pointeur 'message', il fa valloir qu'il pointe sur de la mémoire commune donc partagée. Compliqué... Si une copie ne te fait pas peur, utilise plutôt un tableau de char de taille fixe...

 
Comme le dit Emmanuel, si tu fais un simple transfert de ta structure, ton fils ne récupèrera qu'une adresse vers une chaine vers laquelle il risque de ne pas avoir accès. On retrouve des problèmes analogues en C++ quand on utilise la copie par défaut pour copier des objets contenant des pointeurs (shallow copy). On ne copie que le pointeur et non le pointé.
 
Avec sa solution, ta structure contient tout le message. Il te suffit de faire un simple "write(p[0], &variable, sizeof(nouveau))" pour que l'ensemble de ta structure passe dans le pipe.
 
PS: Il est plus judicieux de nommer ses types "t_qqchose" ou "qqchose_t" (par exemple "t_nouveau" ). Ca améliore la lisibilité du code et tu conserve toujours le token "nouveau" disponible pour le nom de ta variable qui sera justement de type "t_nouveau".

Attention, le suffixe _t est réservé par POSIX.
 
Pas de problème avec *_s ou t_* ou T*...
 

 
il me semble qu'une variable et un type (autre qu'un type de base) peuvent se partager le meme nom, c'est d'ailleur pour ca qu'il faut mettre un nom de type entre parantheses (et qu'il ne faut pas mettre de parantheses dans les autres cas) lorsqu'on le passe à sizeof, pour lever ce genre d'ambiguité

Tiens ? Je ne savais pas.
 

 
Ca veut dire qu'on peut écrire un truc de ce style...

???
 
J'ai jamais essayé...

Oui.
 
C'est moche et ça pose des tas de problèmes aux parseurs C...

 
Ca ne me serait jamais venu à l'idée de le faire tellement j'étais persuadé que c'était pas possible (sans compter que je me mettrais des claques si je me surprenais à faire ça )
On en apprend tous les jours... mais on n'apprend pas que des bonnes choses  

Bjr à tous
Je débute en prog system et surtout avec les dup et pipe anonyme et fork. Ma question est la suivante: Comment faire pour créer un anneau de processus communiquant entre eux. 3 processus par exemple communiquant entre eux en anneau.
 
J'ai une partie d'un code que voici mais que je n'arrive pas à comprendre, notamment pourquoi faire une matrice de tube[][] tout en sachant que le tub doit contenant que les 2 descripteurs read et write du tube.
 
*****************************************************
int tube[atoi(argv[1])][2]; // CETTE MATRICE QUE JE COMPRENDS PAS
 
/* Création d'autant de tubes que de fils */
 for(i=0;i<atoi(argv[1]);i++)
 {
  testpipe=pipe(tube[i]);
  if(testpipe==-1)
   error("Erreur pipe" );
 }
 
 /* Création des fils nécessaire */
 for(i=0;i<atoi(argv[1]);i++)
 {
  fils=fork();
  if(fils==-1)
   error("Erreur fork" );
  else if(fils==0) // Fils
  {
   testdup=dup2(tube[i][0],STDIN_FILENO); //redirection de l'entrée standard du pus_i sur le tube_i[0]
   if(testdup==-1)
    error("Erreur dup2 IN" );
   
   testdup=dup2(tub[(i+1)%atoi(argv[1])][1],STDOUT_FILENO); //redirection de la sorti du pus_i sur le tube_i du pus suivant
   if(testdup==-1)
    error("Erreur dup2 OUT" );
 
   for(j=0;j<atoi(argv[1]);j++)
   {
    testclose=close(tube[j][0]);
    if(testclose==-1)
     error("Erreur close IN" );
     
    testclose=close(tube[j][1];
    if(testclose==-1)
     error("Erreur close OUT" );
   }
   
   execl("jeton",argv[2],NULL);
   error("Erreur execl" );
*****************************************************
 
 
Merci bien pour vos réponses

Maintenant joue avec sizeof

Ben ça te crée un tableau de tubes (2 entiers pour chaque tube) d'une dimension égale au nombre passé en premier argument au programme.
Si l'argument n'est pas un nombre, ça te donne un truc très moche:
 
SYNOPSIS
       #include <stdlib.h>
 
       int atoi(const char *nptr);
 
DESCRIPTION
       La  fonction  atoi()  convertit  le début de la chaîne pointée par nptr en entier de type int. Le résultat est
       identique à un appel à
 
              strtol(nptr, (char **)NULL, 10);
 
       à la différence que atoi() ne détecte pas d'erreur.

slt  
et merci ptichep je vois la stratégie en gros. Une autre question quand le pus1 redirige le STDOUT_FILENO sur le tube2 et que le pus2 redirige son STDIN_FILENO sur le tube2; il y a donc une communication unidirectionnelle établie entre le pus1 et le pus2 via le tube2????
 
Si ce le cas, quel différence y'a t il entre cette technique de redirectiond es descripteurs par défaut, et faire: pour un pus(i) donne, ecrire(tube(i),....) et lire(tube(i-1),...) avec les primitives read et write sans redirection de (STDIN,STDOU)_FILENO.
 
Merci pour ton aide

Disons que rediriger l'entrée/sortie standard vers le tube permet de lire/écrire dans le tube comme s'il s'agissait du clavier/ecran. Si tu n'utilises plus l'entrée/sortie habituelle (clavier/écran) cela peut alléger le code.
Je ne sais pas si ça répond à la question, je n'ai pas lu le code (utilise les balises de code, c'est hachement plus lisible, oui je suis un fainéant).
 
Sinon tu squatterais pas le post d'un autre par hasard?

lol! c'est pas tout à fait ça.
Disons que c'est une correction de TP que le prof nous a filé à la rache donc j'essaie de comprendre. Et là j'ai compris
Merci