probleme avec popen

Version imprimable

probleme avec popen

bonjour
j'ai un petit probleme avec la fonction popen, je me demandais si il y'avait pas un moyen pour inclure une variable dans le premier parametre de cette fonction .
je m'explique j'ai un fichier sous unix sous la forme suivante

toto1: 1 2 3 4 1
toto2: 1 3 5 7 9
........
toto11:0 2 4 1 1

je souhaite ecrire un code en c qui permet de recuperer toutes les lignes
" rien que les entiers " du fichier unix pour les stocker dans un tableau que je vais manipuler par la suite .

voila ce que je suis arrivé a faire ( je suppose que mon fichier ne contiens que toto 1 ,2 et toto3)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# define LNG_MAX  20
# define LAR_MAX  20
# define ATTOUL 1000
# define SEP ""
 
/// 
 
static void clean (char *chaine) ;
 
////
 
int main ( int argc ,  char* argv[] )
 {
        int i = 0 ;
           int j = 0 ;
              FILE* flot = NULL ;
                   int tab[LNG_MAX][LAR_MAX] ;
		      char  put_here [ATTOUL] = "";
                        char* token = NULL ;
 
 
   /** initialisation du tableau **/
 
  for ( i =0 ; i< LNG_MAX ; i++)
   {
       for ( j =0 ; j< LAR_MAX ; j++)
         {
		tab[i][j] = 0 ;
          }
    }
 
  /** reinitialisation des variables i et j a cause de l’incremantation **/
 
  i = 0 ;
    j = 0 ;
 
 
  /** recuperation des données a partir du fichier unix **/
 
  flot = popen ("  grep toto1 /var/sum ", " r ") ;
    flot = popen ("  grep toto2 /var/sum ", " r ") ;
      flot = popen ("  grep toto3 /var/sum ", " r ") ;
 
 
 
  /** verification de l’adresse retourné par popen**/
 
      if ( flot == NULL )
              {
                  printf ("  echec process ") ;
                      break ;
                }
 
 
  /** lecture du flot ligne par ligne **/
 
    while ( !feof (flot) && i< LNG_MAX )
 
        {   
             /** je recupere chaque ligne pour la stocker dans le tableau chaine **/
 
             fgets ( put_here,sizeof(put_here),flot);
 
                   /** je supprime le "\n" et vide mon stdin **/
 
                   clean ( put_here);
 
                          /** je decoupe ma ligne selon le caractere espace "  " **/
 
                            token = strtok (put_here,SEP);    
 
                               /** convertion en entier &Implementation du tableau**/
 
                                  while ( token!=NULL && j< LAR_MAX )
 
                                    { 
				       tab[i][j] = atoi(token);
 
 
                                       		j++;
                                     }
	 i++ ;
 
  pclose(flot);
 
     }
 
  return 0 ; 
 
}
 
 
/*************** fonction clean************/
 
static void purger(void)
{
    int c;
 
    while ((c = getchar()) != '\n' && c != EOF)
    {}
}
 
static void clean (char *chaine)
{
    char *p = strchr(chaine, '\n');
    int c;
 
    if (p)
    {
        *p = 0;
    }
 
    else
    {
        purger();
    }
}

merci à toutes les bonnes ames qui voudront me repondre.

Pourquoi n'ouvres-tu pas directement ton fichier avec fopen()? Le code ci-dessous te convient-il?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define LNG_MAX  20
#define LAR_MAX  20
#define ATTOUL 1000
#define SEP " "
 
static void fclean(char *chaine, FILE *fp);
 
int main (void)
{
    int err = EXIT_SUCCESS;
    FILE* flot = NULL;
 
    flot = fopen("/var/sum", "r") ;
 
    if ( flot != NULL )
    {
        int i = 0;
        int j = 0;
        int tab[LNG_MAX][LAR_MAX] = {0};
        char  put_here[ATTOUL] = "";
        char* token = NULL ;
 
        while (i < LNG_MAX && fgets(put_here, sizeof put_here, flot) != NULL)
        {
            fclean(put_here, flot);
 
            token = strtok(put_here, SEP);
 
            while ((token = strtok(NULL, SEP)) != NULL && j < LAR_MAX)
            {
                tab[i][j] = strtol(token, NULL, 0);
                ++j;
            }
            if (token != NULL && j == LAR_MAX)
            {
                fprintf(stderr, "Avertissement: des entiers n'ont pu être saisis dans le tableau!\n");
            }
            ++i;
        }
 
        if (i == LNG_MAX && feof(flot) == 0)
        {
            fprintf(stderr, "Avertissement: des donnees n'ont pas pu être lues!\n");
        }
 
        fclose(flot), flot = NULL;
    }
    else
    {
        fprintf(stderr, "echec ouverture du fichier") ;
        err = EXIT_FAILURE;
    }
 
    return err;
}
 
static void fclean(char *chaine, FILE *fp)
{
    char *p = strchr(chaine, '\n');
 
    if (p != NULL)
    {
        *p = 0;
    }
    else
    {
        int c;
 
        while ((c = fgetc(fp)) != '\n' && c != EOF)
        {
        }
    }
}

Thierry

Je ne comprends pas le début du code, je ne pense pas qu'il soit nécessaire de nommer des arguments dans le prototype de la fonction.
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <stdio.h> #include <stdlib.h> #include <string.h> #define LNG_MAX 20 #define LAR_MAX 20 #define ATTOUL 1000 #define SEP " " static void fclean(char *chaine, FILE *fp);
Je crois que pour déclarer le prototype de la fonction, cela s'écrit comme ça, sans déclarer d'arguments :
Code:

1 2 static void fclean(char *, FILE *);
, et que cette forme

Code:

static void fclean(char *chaine, FILE *fp)

est réservée à la définition avec le code de la fonction qui
suit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 { char *p = strchr(chaine, '\n'); if (p != NULL) { *p = 0; } else { int c; while ((c = fgetc(fp)) != '\n' && c != EOF) { } } }

22/09/2007, 09h39
Médinoc

Ce n'est pas nécessaire, mais pas dangereux non plus.
Et ça a des avantages quand tu utilises un EDI avec une bibliothèque: L'EDI peut afficher dans une info-bulle le nom des paramètres en plus de leur type, après les avoir lus dans le prototype...
22/09/2007, 19h10
Jayhou

bonjout
le probleme c que fichier ne contient pas que les " toto" il comprend d'autres données que je veux pas utiliser, donc si j'utilise grep c pour simplifier un peu mon code .
25/09/2007, 07h39
Pouic

Rien ne t'empêche de construire dynamiquement la chaîne de caractère contenant la commande que tu souhaites éxécuter.
malloc + strcat ou autre.
cf le man pour plus de détails.

<edit>
L'indentation de ton code est particulièrement horrible.