Récupérer des noms de fichiers passés en arguments

Version imprimable

12/04/2016, 18h00
LeeJustice

Récupérer des noms de fichiers passés en arguments

Bonjour à tous,

Je suis actuellement sur un projet qui travaille avec une liste d'arguments connue (que je traite avec la fonction getopt()) mais en plus de cela le programme doit pouvoir traiter le cas où l’utilisateur entre des noms de fichier (entre 0 et 2 fichiers).

Donc l'idée c'est de récupérer ces éventuelles chaînes de caractères et les passer un fopen().

Une petite aide là-dessus svp?
12/04/2016, 19h24
Christophe

Si j'ai bien compris, tu cherche a vérifier si tes arguments sont des fichier.
Si c'est le cas, regardes du coté de stat.

stat est spécifique à Linux, tu va avoir un équivalent sous Windows.

Mais l'appel de fopen avec test et récupération de l'erreur si il y en a une répondra au besoin.

Salut, merci pour ta réponse.

En fait avant de tester si les arguments sont des fichiers j'aimerais savoir s'il y a des arguments et si oui comment les récupérer?

Pour l'instant voilà comment je gère mes options :
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 const struct option long_options[] = { { "optA", 0, NULL, 'a' }, { "optB", 0, NULL, 'b' }, { "optC", 0, NULL, 'c' }, { "optD", 0, NULL, 'd' }, { NULL, 0, NULL, 0 } }; do { next_option=getopt_long (argc, argv, "abc:d:", long_options, NULL); switch(next_option){ case 'a': flag_a = 1; break; case 'b': flag_b = 1; break; case 'c': argument1 = optarg; break; case 'd': argument2 = optarg; break; } }while(next_option!=-1);
Voilà pour les arguments dont je connais la forme.
Par contre dans mon cahier des charges le programme doit aussi pouvoir traiter le cas où l'utilisateur passe des arguments en plus. Comment puis-je détecter cela? En ajoutant un default : dans mon switch?

EDIT :
En postant le message j'ai eu une idée : implémenter un compteur qui s'incrémentera à chaque fois qu'un argument "attendu" sera détecté et le comparer à argc. Si le compteur est inférieur à argc, c'est que l'utilisateur a ajouté en fin de commande des noms de fichiers que je récupérerai avec argv[compteur].
Je vais essayer d'implémenter ça pour voir si ça peut fonctionner mais je ne pense pas que ce soit la méthode recommandée, ça fait un peu "bricolage".

Up !

J'ai réussi à pondre un truc fonctionnel (cad qui rempli le cahier des charges) mais je ne sais pas si c'est optimisé.

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
#include <stdio.h>
#include <getopt.h>
 
void estPresent(int flag){
    if(flag)
        printf("present\n");
    else
        printf("absent\n");
}
 
int main(int argc, char **argv){
    const struct option long_options[] = {
        { "optA", 0, NULL, 'a' },
        { "optB", 0, NULL, 'b' },
        { "optC", 0, NULL, 'c' },
        { "optD", 0, NULL, 'd' },
        { NULL, 0, NULL, 0 }
    };
    int next_option, flag_a=0, flag_b=0, compteur=1;
    char *argument1="argument 1 par defaut", *argument2="argument 2 par defaut";
    do {
        next_option=getopt_long (argc, argv, "abc:d:", long_options, NULL);
        switch(next_option){
            case 'a':
                flag_a = 1;
                compteur++;
                break;
            case 'b':
                flag_b = 1;
                compteur++;
                break;
            case 'c':
                argument1 = optarg;
                compteur+=2;
                break;
            case 'd':
                argument2 = optarg;
                compteur+=2;
                break;
        }
    }while(next_option!=-1);
    printf("Flag a ");
    estPresent(flag_a);
    printf("Flag b ");
    estPresent(flag_b);
    printf("%s\n", argument1);
    printf("%s\n", argument2);
    if(compteur<argc){
        printf("fichier 1 : %s\n", argv[compteur]);
        if(compteur+1<argc)
            printf("fichier 2 : %s\n", argv[compteur+1]);
    }
}

Qu'est-ce que vous en pensez?