[Améliorations] Programme de manipulations de fichier

Version imprimable

Voir 40 message(s) de cette discussion en une page

Code:

#define MAX_LEN 1000

Met plutôt une puissance de 2,
Le compilateur (euh, plus très sûr que ce soit lui ^^') gère la mémoire par bloc,
Donc là tu perds potentiellement de l'espace.

Code:

1
2
3
4
5
6
7
8
9
10
 
/* 8octets */
int x;
char c1;
char c2;
 
/* 12octets (potentiellement) */
char c1;
int x;
char c2;

(Si quelqu'un peu confirmer ou non ce serait pas de refus ^^)

Code:

int treat(File* my_file, char* option);

Pourquoi ta fonction treat a t-elle besoin d'un pointeur sur l'option ?

Code:

1
2
 
strncpy(my_file.path, optarg, sizeof(my_file.path));

Tu ne testes pas si tu peux copier la totalité de optarg dans my_file.path.
Tu devrais avoir quelque chose du genre :

Code:

1
2
3
4
5
 
if(strlen(optarg) <= MAX_LEN)
  strncpy(path, optarg, strlen(optarg));
else
  return EXIT_FAILURE;

Code:

1
2
3
4
5
6
7
8
 
long read_long(long* ret) /* Lis un long */
{
    char str[MAX_LEN] = {0};
 
    if(read_string(str, 100))
        /* [...] */
}

T'y vas pas avec le dos de la cuillère xD
Tu veux un entier long (donc sur 64bits)
Et tu lui laisses 1000 caractères Oo
En plus tu n'en traites que 100 après =/

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  /* 2^64 = 18 446 744 073 709 551 616 soit 20 caractères */
#define MAXSIZELONG 20 + 1
 
/* [...] */
 
long read_long(long* ret) /* Lis un long */
{
    char str[MAXSIZELONG];
    memset(str, 0, MAXSIZELONG);
 
    if(read_string(str, MAXSIZELONG))
        /* [...] */

Bon sinon, il te reste plus qu'à mettre tout ça en modulaire ^^

voila un exemple d'explosion de code ^^

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
/** main.c **/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h> 
#include "file.h"
 
  /* Base décimale */
#define BASE 10
  /* 2^64 = 18446744073709551616 soit 20 caractères */
#define MAXSIZELONG 20 + 1
 
 
static int treat(char*, char);
static int get_option(char* option);
static int get_filename(char*);
static int again(void);
static void clean(void);
static int read_string(char*, const int);
static long read_long(long*);
 
 
int main(int argc, char *argv[])
{
  int c;
  char path[MAX_LEN];
  char option = ' ';
 
  c = getopt(argc, argv, "c:r:w:");
 
  printf("%d : %d\n", sizeof(path), strlen(path));
 
  if(c != EOF)
  {
    option = c;
    if(strlen(optarg) <= MAX_LEN)
      strncpy(path, optarg, strlen(optarg));
    else
      return EXIT_FAILURE;
  }
 
  return (treat(path, option) == FAIL) ? EXIT_FAILURE : EXIT_SUCCESS;
}
 
 
static int treat(char* path, char option)
{
  if(option == ' ' && get_option(&option) == FAIL)
    return FAIL;
  if(strlen(path) == 0 && get_filename(path) == FAIL)
    return FAIL;
 
  switch(option)
  {
    case 'r' :
        if(read_file(path) == SUCCESS)
          return SUCCESS;
      break;
    case 'c' :
        if(create_file(path) == SUCCESS)
          return SUCCESS;
      break;
    case 'w' :
        if(write_file(path) == SUCCESS)
          return SUCCESS;
      break;
  }
 
  path[0] = '\0';
  return (again() == SUCCESS) ? treat(path, option) : FAIL;  
}
 
static int get_option(char* option)
{
  long ret;
 
  printf("\n\n\t  zReader - Manipulez vos fichiers");
  printf("\n\n\n\tMENU\n");
  printf(" 1 - Lire un fichier\n");
  printf(" 2 - Créer un fichier\n");
  printf(" 3 - Ecrire dans un fichier\n");
  printf(" 4 - Quitter\n\n");
 
  do
  {
    printf(" Votre choix ? ");
    if(read_long(&ret) == FAIL)
      return FAIL;
 
    if(ret == 1)
      *option = 'r';
    else if(ret == 2 || ret == 3)
      *option = 'w';
    else if(ret == 4)
      return FAIL;
 
  } while(ret <= 0 || ret >= 4);
 
  return SUCCESS;    
}
 
static int get_filename(char* path)
{
  printf("\n Entrez le nom du fichier concerné : ");
  return read_string(path, MAX_LEN);
}
 
static int again(void)
{
  int c;
 
  do
  {
    printf("\n Erreur. Recommencer ? (o/n) ");
    c = fgetc(stdin);
    clean();
  } while(c != 'o' && c != 'n');
 
  return(c == 'o') ? SUCCESS : FAIL;
}
 
static void clean(void) /* Nettoie le buffer */
{
  int c = 0;
  while ((c = getchar()) != '\n' && c != EOF);
}
 
static int read_string(char *str, const int length) /* Lis une chaîne de caractère */
{
  char *ptr = NULL;
 
  if(fgets(str, length, stdin) != NULL)
  {
    ptr = strchr(str, '\n');
 
    if(ptr != NULL)
      *ptr = '\0';
    else
      clean();
 
    return SUCCESS;
  }
  clean(); 
  return FAIL;
}
 
static long read_long(long* ret) /* Lis un long */
{
  char str[MAXSIZELONG];
  memset(str, 0, MAXSIZELONG);
 
  if(read_string(str, MAXSIZELONG))
  {
    *ret = strtol(str, NULL, BASE);
    return SUCCESS;
  }
 
  return FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
/** file.h **/
#ifndef _FILE_H
  #define _FILE_H
 
  #include <stdio.h>
 
    /* Taille de chaîne maximale */
  #define MAX_LEN 1024
    /* Constantes pour les retours de fonction */
  #define FAIL 0
  #define SUCCESS 1
 
   /* Lis un fichier */
  int read_file(char* path);
 
   /* Crée un fichier */
  int create_file(char* path);
 
   /* Ecrit dans un fichier */
  int write_file(char* path);
 
#endif

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
 
/** file.c **/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "file.h"
 
static int close_file(FILE*);
 
int read_file(char* path) /* Lis un fichier */
{
  char str[MAX_LEN];
  FILE *f;
 
  if((f = fopen(path, "r")) == NULL)
    return FAIL;
 
  printf("\n Contenu du fichier : \n\n");
 
  if(fgetc(f) != EOF)
  {
    fseek(f, 0, SEEK_SET);
 
    while(fgets(str, sizeof(str), f) != NULL)
      printf("%s", str);
  }
  else
    printf(" Désolé, le fichier est vide !\n");
 
  return close_file(f);
}
 
int create_file(char* path) /* Crée un fichier */
{
  FILE *f;
  if((f = fopen(path, "w")) == NULL)
    return FAIL;
 
  printf("\n Le fichier a été créé avec succès !\n");
  return close_file(f);
}
 
int write_file(char* path) /* Ecrit dans un fichier */
{
  char str[MAX_LEN * 2], *stop;
  int len;
  FILE *f;
 
  if((f = fopen(path, "w")) == NULL)
    return FAIL;
 
  stop = "close_file";
  len = strlen(stop);
 
  printf("\n Saisissez le texte à mettre dans le fichier");
  printf("(pour fermer, tapez \"%s\") : \n\n", stop);
 
  while(fgets(str, sizeof(str), stdin) != NULL)
  { 
    if(strncmp(str, stop, len))
      break;
    fputs(str, f);
  } 
 
  return close_file(f);
}
 
static int close_file(FILE* f)
{
  return (fclose(f) == 0) ? SUCCESS : FAIL;
}

Tu fais quoi après ?
La copie de fichiers ?
Des statistiques sur les fichiers ?
Recherche dans un fichier ?
... ^^

24/08/2011, 14h00
lucas-84

J'ai simplement quelques questions à poser après cette nouvelle réponse constructive.

1) Quelle est la différence entre l'utilisation de la fonction memset et l'affectation = {0} ?
2) Pourquoi #define [...] 20+1 ? :? [Edit] Oublie la deuxième question, j'ai relu les commentaires+le texte avant. [/Edit]

Merci d'avance.

memset remplit une zone mémoire de taille N avec un entier unique.
Si je ne m'abuse, elle est très proche de la machine et est donc plus performante.

La syntaxe :

Code:

char tab[X] = {0};

Fait la même chose mais ne peut être fait qu'à l'initialisation.
Et c'est au compilateur de gérer l'optimisation (faire une boucle ou utiliser memset ou autre ...).
Après, elle permet d'initialiser des structures plus finement :

Code:

1
2
3
4
5
6
 
  /* suite de Fibonacci */
int i;
int fibo[X] = {0, 1}; /* la suite est mise à 0 */
for(i=2; i<X; ++i)
  fibo[i] = fibo[i-1] + fibo[i-2];

Et même des structures complexes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
typedef struct
{
  int i;
  char c;
  char s[5];
} S;
 
int i;
 
  /* on initialise la 1ere structure, les autres seront mises à NULL */
  /* /!\ rappel : NULL = (void*)0 /!\ */
S s[2] = {{10,'c','plop'}};
 
for(i=0; i<2; ++i)
  (&s[i] != NULL) ?
    printf("s[%d] = %d, %c, %s\n", i, s[i].i, s[i].c, s[i].s) : NULL;
 
  /* on peut remettre une valeur par défaut via memset */
memset(s, 0, 2 * sizeof(S));
for(i=0; i<2; ++i)
  (&s[i] != NULL) ?
    printf("s[%d] = %d, %c, %s\n", i, s[i].i, s[i].c, s[i].s) : NULL;

Tu peux même laisser le compilateur gérer des tailles dynamiquement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
struct _contact
{
	char nom[20];
	char prenom[20];
	char numero[20];
} repertoire[] = /* on ne précise pas combien il y a d'éléments */
    {{"John", "DOE", "+331.02.03.04.05"},
     {"Jane", "DOE", "+331.03.04.05.06"}};
 
int i;
 /* le compilateur nous a bien alloué un tableau de 2 'struct _contact" */
int len = (sizeof(repertoire) / sizeof(struct _contact));
 
for(i=0; i<len; ++i)
  printf("> %s %s : %s\n", repertoire[i].nom,
    repertoire[i].prenom, repertoire[i].numero);

Très intéressant. Merci pour cette explication précise. :)

De mon côté, j'ai séparé mon code en fichiers, comme demandé. :mouarf:
Huit fichiers, ça fait beaucoup au vu du nombre de lignes de code, mais bon.

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
/* main.c */
 
 
#include <getopt.h> 
 
#include "file.h"
#include "tools.h"
#include "directives.h"
#include "program.h"
 
 
int main(int argc, char *argv[])
{
    int c, ret;
    char option = ' ';
    char path[MAX_LEN];
 
    c = getopt(argc, argv, "c:r:w:");
 
    if(c != EOF)
    {
	option = (char)c;
 
	if(strlen(optarg) <= MAX_LEN)
  	    strncpy(path, optarg, strlen(optarg));
 
	else
   	    return EXIT_FAILURE;
    }
 
    return (treat(path, option) == FAIL) ? EXIT_FAILURE : EXIT_SUCCESS;
}

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
/* program.c */
 
 
#include "file.h"
#include "tools.h"
#include "directives.h"
#include "program.h"
 
 
/* Fonction principale du programme */
int treat(char* path, char option)
{
    if(option == ' ' && get_option(&option) == FAIL)
    	return FAIL;
 
    if(strlen(path) == 0 && get_filename(path) == FAIL)
    	return FAIL;
 
    switch(option)
    {
    	case 'r':
            if(read_file(path) == SUCCESS)
                return SUCCESS;
 
            break;
 
    	case 'c':
            if(create_file(path) == SUCCESS)
           	return SUCCESS;
 
      	    break;
 
    	case 'w':
            if(write_file(path) == SUCCESS)
          	return SUCCESS;
 
      	    break;
    }
 
    path[0] = '\0';
 
    return (again() == SUCCESS) ? treat(path, option) : FAIL;    
}
 
/* Demande la saisie de la fonctionnalité à utiliser */ 
int get_option(char* option)
{
    long ret;
 
    printf("\n\n          zReader - Manipulez vos fichiers"
	   "\n\n\n   MENU\n"
           " 1 - Lire un fichier\n"
           " 2 - Créer un fichier\n"
           " 3 - Ecrire dans un fichier\n"
	   " 4 - Quitter \n\n");
    do
    {
        printf(" Votre choix ? ");
        if(read_long(&ret) == FAIL)
	    return FAIL;
 
	if(ret == 1)
	    *option = 'r';
 
	else if(ret == 2 || ret == 3)
	    *option = 'w';
 
	else if(ret == 4)
	    return FAIL;
 
    } while(ret <= 0 || ret >= 4);
 
    return SUCCESS;    
}
 
/* Demande la saisie du nom du fichier en question */
int get_filename(char* path)
{
    printf("\n Entrez le nom du fichier concerné : ");
 
    return read_string(path, MAX_LEN);
}
 
/* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
int again(void)
{
    int c;
 
    do
    {
	printf("\n Erreur. Recommencer ? (o/n) ");
    	c = fgetc(stdin);
    	clean();
    } while(c != 'o' && c != 'n');
 
    return(c == 'o') ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* program.h */
 
 
#ifndef _PROGRAM_H
#define _PROGRAM_H
 
    /* Fonction principale du programme */
    int treat(char*, char);
 
    /* Demande la saisie de la fonctionnalité à utiliser */
    int get_option(char*);
 
    /* Demande la saisie du nom du fichier en question */
    int get_filename(char*);
 
    /* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
    int again(void);
 
#endif

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
/* file.c */
 
 
#include "file.h"
#include "tools.h"
#include "directives.h"
#include "program.h"
 
 
static int close_file(FILE*);
 
 
/* Lis un fichier */
int read_file(char* path) 
{
    FILE* f;
    char str[MAX_LEN];
 
    if((f = fopen(path, "r")) == NULL)
    	return FAIL;
 
    printf("\n Contenu du fichier : \n\n");
 
    if(fgetc(f) != EOF)
    {
    	fseek(f, 0, SEEK_SET);
 
    	while(fgets(str, sizeof(str), f) != NULL)
      	    printf("%s", str);
    }
 
    else
    	printf(" Désolé, le fichier est vide !\n");
 
    return close_file(f);
}
 
/* Crée un fichier */ 
int create_file(char* path) 
{
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    printf("\n Le fichier a été créé avec succès !\n");
 
    return close_file(f);
}
 
/* Ecrit dans un fichier */ 
int write_file(char* path) 
{
    char str[MAX_LEN * 2], *stop;
    int len;
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    stop = "close_file";
    len = strlen(stop);
 
    printf("\n Saisissez le texte à mettre dans le fichier");
    printf("(pour fermer, tapez \"%s\") : \n\n", stop);
 
    while(fgets(str, sizeof(str), stdin) != NULL)
    { 
    	if(strncmp(str, stop, len))
      	    break;
 
    	fputs(str, f);
    } 
 
    return close_file(f);
}
 
/* Ferme un fichier */ 
static int close_file(FILE* f)
{
    return (fclose(f) == 0) ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* file.h */
 
 
#ifndef _FILE_H
#define _FILE_H
 
   /* Lis un fichier */
    int read_file(char*);
 
   /* Crée un fichier */
    int create_file(char*);
 
   /* Ecrit dans un fichier */
    int write_file(char*);
 
#endif

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
/* tools.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "directives.h"
#include "program.h"
 
 
/* Nettoie le buffer */
void clean(void) 
{
    int c = 0;
    while ((c = getchar()) != '\n' && c != EOF);
}
 
/* Lis une chaîne de caractère */
int read_string(char *str, const int length) 
{
    char *ptr = NULL;
 
    if(fgets(str, length, stdin) != NULL)
    {
        ptr = strchr(str, '\n');
 
        if(ptr != NULL)
            *ptr = '\0';
 
        else
            clean();
 
        return SUCCESS;
    }
 
    else
    {
        clean(); 
 
        return FAIL;
    }
}
 
/* Lis un long */
long read_long(long* ret) 
{
    char str[MAX_LONG];
    memset(str, 0, MAX_LONG);
 
    if(read_string(str, MAX_LONG))
    {
        *ret = strtol(str, NULL, 10);
        return SUCCESS;
    }
 
    return FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* tools.h */
 
 
#ifndef _TOOLS_H
#define _TOOLS_H
 
    /* Nettoie le buffer */
    void clean(void);
 
    /* Lis une chaîne de caractère */
    int read_string(char*, const int);
 
    /* Lis un long */
    long read_long(long*);
 
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* directives.h */
 
 
#ifndef _DIRECTIVES_H
#define _DIRECTIVES_H
 
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
 
 
    /* Taille de chaîne maximale */
    #define MAX_LEN 	1024
 
    /* Taille de long maximale */
    #define MAX_LONG	20 + 1	
 
    /* Constantes pour les retours de fonction */
    #define FAIL 	0
    #define SUCCESS 	1
 
#endif

Note : J'ai finalement abandonné cette structure qui n'aura causé que du tort...
Je réfléchis maintenant à d'autres améliorations. :D

24/08/2011, 16h26
brachior
Citation:

Envoyé par lucas-84

De mon côté, j'ai séparé mon code en fichiers, comme demandé. :mouarf:
Huit fichiers, ça fait beaucoup au vu du nombre de lignes de code, mais bon.

Il ne faut pas réfléchir comme ça ...
Il peut y avoir une fonction par fichier ...
Tu dois exploser ton programme en autant de "mini bibliothèques"
Qu'il y a de regroupement possible.

Si je regarde ton découpage,
Je vois tout de suite que tu comprends les méthodes des fichiers comme une bibliothèque à par entière.
Et que tu souhaites en former une autre d'outils non liés à ce projet.
C'est très bien, ça montre bien la réutilisation possible du code.
(En informatique on parle de "réutilisabilité" ...
Mais je trouve ça moche ^^ On dirait Mme Royal qu'invente des mots ^^)

Pour directives.h, je sais pas trop,
Les defines sont plutôt lié à ce projet.
Je veux dire, MAX_LEN est imposé par file.c ...
file.c se contre fiche de MAX_LONG, ..., ...
De plus, pour quelqu'un voulant utiliser file.c, il va pas forcement comprendre qu'il faille inclure directives.h Oo

Sinon, un *.*h est une interface aux yeux des développeurs,
Il est sensé montré les dépendances et les interactions
que le développeur aura à/pourra faire en utilisant cette bibliothèque.
Donc il faut supprimer toute chose inutile.
Pour bien mettre en évidence l'utile.
De plus, même si le pré-processeur fait un "copié/collé" lors des include,
Il ne faut pas s'en servir comme tel.

Quand tu écris dans ton directives.h :
Code:

1 2 3 4 #include <stdio.h> #include <stdlib.h> #include <string.h>
On se demande pourquoi l'inclusion est nécessaire (on ne sait pas à quoi ce fichier servira)
Et lorsqu'on regarde main.c, on se demande comment il utilise strlen par exemple.
Ça perd en lisibilité, et ça peut causer des inclusions circulaires =/

Citation:

Envoyé par lucas-84

Note : J'ai finalement abandonné cette structure qui n'aura causé que du tort...

Ton programme actuel ne gère qu'un fichier à la fois,
La structure est donc inutile ...
Maintenant imagine que tu gères un éditeur de texte ...
Tu devras peut être gérer une liste de fichiers ...
Et pour chaque fichier, peut être garder des informations (path, original, auteur, ...)

Citation:

Envoyé par lucas-84

Je réfléchis maintenant à d'autres améliorations. :D

Tu as plein de choses à faire avec les fichiers ^^
La recherche de mot, la comparaison de fichier, la copie de fichier,
La coloration syntaxique d'un langage particulier, ..., ...
Tu peux laisser libre ton imagination ^^
24/08/2011, 16h36
lucas-84

Citation:

Pour directives.h, je sais pas trop,
Les defines sont plutôt lié à ce projet.
Je veux dire, MAX_LEN est imposé par file.c ...
file.c se contre fiche de MAX_LONG, ..., ...
De plus, pour quelqu'un voulant utiliser file.c, il va pas forcement comprendre qu'il faille inclure directives.h Oo

directives.h ne sert à rien, alors ?
24/08/2011, 16h46
brachior

Pour moi, non, il faut répartir son contenu dans les headers appropriés.
Les headers forment des blocs, le mieux c'est qu'ils aient le moins de dépendances possibles :)

Très bien, me revoilà ! :mrgreen:

En fait, j'ai une petite question à vous poser.
Voilà, j'ai créé une nouvelle fonction copy_file, que voici :
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 /* Copie un fichier */ int copy_file(char *src, char *dst) { char str[MAX_LEN * 2]; FILE *f1, *f2; if(strncmp(src, "", MAX_LEN) == 0) { if(get_filename("Entrez le nom du fichier à copier", src) == FAIL) return FAIL; if(get_filename("Entrez le nom de la destination", dst) == FAIL) return FAIL; } if((f1 = fopen(src, "r")) == NULL) return FAIL; if((f2 = fopen(dst, "w")) == NULL) return FAIL; if(fgetc(f1) != EOF) { fseek(f1, 0, SEEK_SET); while(fgets(str, sizeof(str), f1) != NULL) fputs(str, f2); } printf("\n Le fichier %s a bien été copié dans le fichier %s !\n", src, dst); if(close_file(f1) == FAIL) return FAIL; return close_file(f2); }
Elle n'est pas parfaite, je m'en doute, mais le problème ne vient pas de là.
En fait, j'aimerais que l'utilisateur puisse utiliser la fonctionnalité de copier un fichier directement en ligne de commande, seulement, pour qu'il puisse le faire, il faut qu'il tape l'option -cp suivi de deux arguments. Et, ce que je n'arrive pas à faire, c'est récupérer ces deux arguments avec getopt.
En effet, la page de commande de getopt que j'ai trouvé est assez brouillonne, et j'ai du mal à saisir toutes les fonctionnalités qui sont en ma possession.

Merci d'avance ! :(

Ah, j'oubliais !

Mon code en entier !

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
/* main.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h> 
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
int main(int argc, char *argv[])
{
    int c, ret;
    char option = ' ';
    char path[MAX_LEN];
 
    c = getopt(argc, argv, "cr:r:w:cp:");
 
    if(c != EOF)
    {
	option = (char)c;
 
	if(strlen(optarg) <= MAX_LEN)
  	    strncpy(path, optarg, strlen(optarg));
 
	else
   	    return EXIT_FAILURE;
    }
 
    return (treat(path, option) == FAIL) ? EXIT_FAILURE : EXIT_SUCCESS;
}

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
/* program.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
/* Fonction principale du programme */
int treat(char* path, char option)
{ 
    /* Pour le moment, je crée les variables dans cette fonction.
       Ce ne sera plus le cas quand getopt aura été configuré pour
       copier un fichier en ligne de commande */
    char src[MAX_LEN] = "";
    char dst[MAX_LEN] = "";
 
    if(option == ' ' && get_option(&option) == FAIL)
    	return FAIL;
 
    if(strlen(path) == 0 && get_filename("Entrez le nom du fichier concerné", path) == FAIL)
    	return FAIL;
 
    if(option == 'r')
	return read_file(path);
 
    if(option == 'c')
	return create_file(path);
 
    if(option == 'd')
	return copy_file(src, dst);
 
    if(option == 'w')
	return write_file(path);
 
    path[0] = '\0';
 
    return (again() == SUCCESS) ? treat(path, option) : FAIL;    
}
 
/* Demande la saisie de la fonctionnalité à utiliser */ 
int get_option(char* option)
{
    long ret;
 
    printf("\n\n          zReader - Manipulez vos fichiers"
	   "\n\n\n   MENU\n"
           " 1 - Lire un fichier\n"
           " 2 - Créer un fichier\n"
           " 3 - Ecrire dans un fichier\n"
	   " 4 - Copier un fichier\n"
	   " 5 - Quitter \n\n");
    do
    {
        printf(" Votre choix ? ");
        if(read_long(&ret) == FAIL)
	    return FAIL;
 
	if(ret == 1)
	    *option = 'r';
 
	else if(ret == 2 || ret == 3)
	    *option = 'w';
 
	else if(ret == 4)
	    *option = 'd';
 
	else if(ret == 5)
	    return FAIL;
 
    } while(ret <= 0 || ret >= 6);
 
    return SUCCESS;    
}
 
/* Demande la saisie du nom du fichier en question */
int get_filename(char* str, char* path)
{
    printf("\n %s : ", str);
 
    return read_string(path, MAX_LEN);
}
 
/* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
int again(void)
{
    int c;
 
    do
    {
	printf("\n Recommencer ? (o/n) ");
    	c = fgetc(stdin);
    	clean();
    } while(c != 'o' && c != 'n');
 
    return(c == 'o') ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* program.h */
 
 
#ifndef _PROGRAM_H
#define _PROGRAM_H
 
    /* Fonction principale du programme */
    int treat(char*, char);
 
    /* Demande la saisie de la fonctionnalité à utiliser */
    int get_option(char*);
 
    /* Demande la saisie du nom du fichier en question */
    int get_filename(char*, char*);
 
    /* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
    int again(void);
 
#endif

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
/* file.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
static int close_file(FILE*);
 
 
/* Lis un fichier */
int read_file(char* path) 
{
    FILE* f;
    char str[MAX_LEN * 2];
 
    if((f = fopen(path, "r")) == NULL)
    	return FAIL;
 
    printf("\n Contenu du fichier : \n\n");
 
    if(fgetc(f) != EOF)
    {
    	fseek(f, 0, SEEK_SET);
 
    	while(fgets(str, sizeof(str), f) != NULL)
      	    printf("%s", str);
    }
 
    else
    	printf(" Désolé, le fichier est vide !\n");
 
    return close_file(f);
}
 
/* Crée un fichier */ 
int create_file(char* path) 
{
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    printf("\n Le fichier %s a été créé avec succès !\n", path);
 
    return close_file(f);
}
 
/* Ecrit dans un fichier */ 
int write_file(char* path) 
{
    char str[MAX_LEN * 2], *stop;
    int len;
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    stop = "close_file";
    len = strlen(stop);
 
    printf("\n Saisissez le texte à mettre dans le fichier");
    printf("(pour fermer, tapez \"%s\") : \n\n", stop);
 
    while(fgets(str, sizeof(str), stdin) != NULL)
    { 
    	if(strncmp(str, stop, len))
      	    break;
 
    	fputs(str, f);
    } 
 
    return close_file(f);
}
 
/* Copie un fichier */
int copy_file(char *src, char *dst)
{
    char str[MAX_LEN * 2];
    FILE *f1, *f2;
 
    if(strncmp(src, "", MAX_LEN) == 0)
    {
	if(get_filename("Entrez le nom du fichier à copier", src) == FAIL)
	    return FAIL;
 
	if(get_filename("Entrez le nom de la destination", dst) == FAIL)
	    return FAIL;
    }
 
    if((f1 = fopen(src, "r")) == NULL)
	return FAIL;
 
    if((f2 = fopen(dst, "w")) == NULL)
	return FAIL;
 
    if(fgetc(f1) != EOF)
    {
    	fseek(f1, 0, SEEK_SET);
 
    	while(fgets(str, sizeof(str), f1) != NULL)
      	    fputs(str, f2);
    }    
 
    printf("\n Le fichier %s a bien été copié dans le fichier %s !\n", src, dst);
 
    if(close_file(f1) == FAIL)
	return FAIL;
 
    return close_file(f2);
}
 
/* Ferme un fichier */ 
static int close_file(FILE* f)
{
    return (fclose(f) == 0) ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* file.h */
 
 
#ifndef _FILE_H
#define _FILE_H
 
    /* Lis un fichier */
    int read_file(char*);
 
    /* Crée un fichier */
    int create_file(char*);
 
    /* Ecrit dans un fichier */
    int write_file(char*);
 
    /* Copie un fichier */
    int copy_file(char[], char[]);
 
#endif

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
/* tools.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
/* Nettoie le buffer */
void clean(void) 
{
    int c = 0;
    while ((c = getchar()) != '\n' && c != EOF);
}
 
/* Lis une chaîne de caractère */
int read_string(char *str, const int length) 
{
    char *ptr = NULL;
 
    if(fgets(str, length, stdin) != NULL)
    {
        ptr = strchr(str, '\n');
 
        if(ptr != NULL)
            *ptr = '\0';
 
        else
            clean();
 
        return SUCCESS;
    }
 
    else
    {
        clean(); 
 
        return FAIL;
    }
}
 
/* Lis un long */
long read_long(long* ret) 
{
    char str[MAX_LONG];
    memset(str, 0, MAX_LONG);
 
    if(read_string(str, MAX_LONG))
    {
        *ret = strtol(str, NULL, 10);
        return SUCCESS;
    }
 
    return FAIL;
}

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
/* tools.h */
 
 
#ifndef _TOOLS_H
#define _TOOLS_H
 
    /* Constantes pour les retours de fonction */
    #define FAIL 	0
    #define SUCCESS 	1
 
    /* Taille de long maximale */
    #define MAX_LONG	20 + 1	
 
    /* Taille de chaîne maximale */
    #define MAX_LEN 	1024
 
 
    /* Nettoie le buffer */
    void clean(void);
 
    /* Lis une chaîne de caractère */
    int read_string(char*, const int);
 
    /* Lis un long */
    long read_long(long*);
 
#endif

C'est rare les options qui prennent deux arguments Oo
Euh je sais pas s'il y a un mécanisme propre,
Mais tu peux toujours le faire à la main :

Ici, a et b n'ont pas d'argument, c en a 2 et d un seul.
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 #include <stdio.h> #include <stdlib.h> #include <getopt.h> int main (int argc, char *argv[]) { char c; while ( (c = getopt(argc, argv, "abc:d:")) != -1) { switch(c) { case 'a': printf("option a\n"); break; case 'b': printf("option b\n"); break; case 'c': if(optind > argc || '-' == argv[optind][0]) printf ("Nombre d'arguments invalide pour l'option %c\n", c); else printf("option c avec les arguments %s et %s\n", optarg, argv[optind++]); break; case 'd': printf("option d avec l'argument %s\n", optarg); break; default: break; } } return EXIT_SUCCESS; }
Pour ta méthode,
Je ne comprends pas ton test :
Code:

1 2 if(strncmp(src, "", MAX_LEN) == 0)
D'une, tester sur MAX_LEN sachant qu'une des deux chaines fait zéro c'est peu judicieux,
De deux, pourquoi un strncmp au lieu d'un strcmp (qui testera la taille en premier) ?
Et tu ne testes pas si les paramètres sont NULL Oo

Y a une implémentation sur la FAQ de Developpez ;)

26/08/2011, 10h34
lucas-84

Citation:

C'est rare les options qui prennent deux arguments Oo

D'un autre côté, j'étais un peu obligé. :oops:

Le « truc » que je cherchais c'était le « argv[optind++] » qui m'est bien utile. :ccool:

Citation:

D'une, tester sur MAX_LEN sachant qu'une des deux chaines fait zéro c'est peu judicieux,
De deux, pourquoi un strncmp au lieu d'un strcmp (qui testera la taille en premier) ?
Et tu ne testes pas si les paramètres sont NULL Oo

C'est compris, j'utilise finalement un bon vieux strcmp. Par contre, je ne comprends pas pourquoi il faudrait que je teste si les paramètres sont NULL. Je teste si ils sont égaux à "", ce n'est pas assez ? :?

J'ai regardé l'implémentation de la FAQ, mais je préfère garder la mienne. :mouarf: En effet, j'ai peu l'habitude d'utiliser les fonctions fread et fwrite. De plus, ma fonction n'est pas très longue, je ne vois pas l'intérêt d'y intégrer du code que je comprends moins et qui n'est pas de moi...

Sinon, j'ai créé un tableau de chaînes de caractère, path, qui, en path[0], contient le premier argument de l'utilisateur, en path[1] le deuxième (pour la fonction copy_file), etc.

Sinon, je pensais prendre une orientation plus 'shell' si l'utilisateur n'entrait pas d'argument. Au lieu de faire un menu, pourquoi ne pas recoder un mini-shell contenant uniquement les fonctionnalités de création, de lecture, d'écriture et de copie ? (voire d'autres fonctions ultérieurement). J'intégrerais ainsi un système de man (Unixiens, vous me suivez 8-) ) qui permettrait à l'utilisateur de savoir quelles sont les commandes dont il dispose.

Oh My God, j'oublie tout le temps de mettre mon code... :(

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
/* main.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h> 
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
int main(int argc, char *argv[])
{
    int c;
    char option = ' ', str[2][MAX_LEN] = {{""}, {""}};
 
    c = getopt(argc, argv, "c:r:w:d:");
 
    if(c != EOF)
    {
	option = (char)c;
 
	if(strlen(optarg) <= MAX_LEN)
  	    strncpy(str[0], optarg, strlen(optarg));
 
	else
   	    return EXIT_FAILURE;
 
	if(option == 'd' && (strlen(argv[optind++]) <= MAX_LEN))
	    strncpy(str[1], argv[optind++], strlen(argv[optind++]));
 
	else
	    return EXIT_FAILURE;
    }
 
    return (treat(str, option) == FAIL) ? EXIT_FAILURE : EXIT_SUCCESS;
}

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
/* program.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
/* Fonction principale du programme */
int treat(char path[][MAX_LEN], char option)
{ 
    if(option == ' ' && get_option(&option) == FAIL)
    	return FAIL;
 
    if((option == 'r' || option == 'c' || option == 'w') &&
       (strlen(path[0]) == 0) && 
       (get_filename("Entrez le nom du fichier concerné", path[0]) == FAIL))
    	return FAIL;
 
    if(option == 'r')
	return read_file(path[0]);
 
    if(option == 'c')
	return create_file(path[0]);
 
    if(option == 'd')
	return copy_file(path[0], path[1]);
 
    if(option == 'w')
	return write_file(path[0]);
 
    path[0][0] = '\0';
 
    return (again() == SUCCESS) ? treat(path, option) : FAIL;    
}
 
/* Demande la saisie de la fonctionnalité à utiliser */ 
int get_option(char* option)
{
    long ret;
 
    printf("\n\n          zReader - Manipulez vos fichiers"
	   "\n\n\n   MENU\n"
           " 1 - Lire un fichier\n"
           " 2 - Créer un fichier\n"
           " 3 - Ecrire dans un fichier\n"
	   " 4 - Copier un fichier\n"
	   " 5 - Quitter \n\n");
    do
    {
        printf(" Votre choix ? ");
        if(read_long(&ret) == FAIL)
	    return FAIL;
 
	if(ret == 1)
	    *option = 'r';
 
	else if(ret == 2 || ret == 3)
	    *option = 'w';
 
	else if(ret == 4)
	    *option = 'd';
 
	else if(ret == 5)
	    return FAIL;
 
    } while(ret <= 0 || ret >= 6);
 
    return SUCCESS;    
}
 
/* Demande la saisie du nom du fichier en question */
int get_filename(char* str, char* path)
{
    printf("\n %s : ", str);
 
    return read_string(path, MAX_LEN);
}
 
/* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
int again(void)
{
    int c;
 
    do
    {
	printf("\n Recommencer ? (o/n) ");
    	c = fgetc(stdin);
    	clean();
    } while(c != 'o' && c != 'n');
 
    return(c == 'o') ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* program.h */
 
 
#ifndef _PROGRAM_H
#define _PROGRAM_H
 
    /* Fonction principale du programme */
    int treat(char[][MAX_LEN], char);
 
    /* Demande la saisie de la fonctionnalité à utiliser */
    int get_option(char*);
 
    /* Demande la saisie du nom du fichier en question */
    int get_filename(char*, char*);
 
    /* Demande à l'utilisateur s'il veut recommencer suite à une erreur */
    int again(void);
 
#endif

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
/* file.c */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "file.h"
#include "tools.h"
#include "program.h"
 
 
static int close_file(FILE*);
 
 
/* Lis un fichier */
int read_file(char* path) 
{
    FILE* f;
    char str[MAX_LEN * 2];
 
    if((f = fopen(path, "r")) == NULL)
    	return FAIL;
 
    printf("\n Contenu du fichier : \n\n");
 
    if(fgetc(f) != EOF)
    {
    	fseek(f, 0, SEEK_SET);
 
    	while(fgets(str, sizeof(str), f) != NULL)
      	    printf("%s", str);
    }
 
    else
    	printf(" Désolé, le fichier est vide !\n");
 
    return close_file(f);
}
 
/* Crée un fichier */ 
int create_file(char* path) 
{
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    printf("\n Le fichier %s a été créé avec succès !\n", path);
 
    return close_file(f);
}
 
/* Ecrit dans un fichier */ 
int write_file(char* path) 
{
    char str[MAX_LEN * 2], *stop;
    int len;
    FILE *f;
 
    if((f = fopen(path, "w")) == NULL)
    	return FAIL;
 
    stop = "close_file";
    len = strlen(stop);
 
    printf("\n Saisissez le texte à mettre dans le fichier");
    printf("(pour fermer, tapez \"%s\") : \n\n", stop);
 
    while(fgets(str, sizeof(str), stdin) != NULL)
    { 
    	if(strncmp(str, stop, len))
      	    break;
 
    	fputs(str, f);
    } 
 
    return close_file(f);
}
 
/* Copie un fichier */
int copy_file(char *src, char *dst)
{
    char str[MAX_LEN * 2];
    FILE *f1, *f2;
 
    if(strcmp(src, "") == 0)
    {
	if(get_filename("Entrez le nom du fichier à copier", src) == FAIL)
	    return FAIL;
 
	if(get_filename("Entrez le nom de la destination", dst) == FAIL)
	    return FAIL;
    }    
 
    if((f1 = fopen(src, "r")) == NULL)
	return FAIL;
 
    if((f2 = fopen(dst, "w")) == NULL)
	return FAIL;
 
    while(fgets(str, sizeof(str), f1) != NULL)
        fputs(str, f2);  
 
    printf("\n Le fichier %s a bien été copié dans le fichier %s !\n", src, dst);
 
    if(close_file(f1) == FAIL)
	return FAIL;
 
    return close_file(f2);
}
 
/* Ferme un fichier */ 
static int close_file(FILE* f)
{
    return (fclose(f) == 0) ? SUCCESS : FAIL;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* file.h */
 
 
#ifndef _FILE_H
#define _FILE_H
 
    /* Lis un fichier */
    int read_file(char*);
 
    /* Crée un fichier */
    int create_file(char*);
 
    /* Ecrit dans un fichier */
    int write_file(char*);
 
    /* Copie un fichier */
    int copy_file(char[], char[]);
 
#endif

Je ne vous passe pas tools.c et tools.h, ils ne changent pas et ne changeront sûrement pas.

Désolé pour le temps de réponse :roll:

Citation:

Envoyé par lucas-84

Par contre, je ne comprends pas pourquoi il faudrait que je teste si les paramètres sont NULL. Je teste si ils sont égaux à "", ce n'est pas assez ? :?

Il y a une très grosse différence entre "" et NULL.
Le premier indique que c'est une chaine de un caractère contenant le mot vide (\0)
Le deuxième est un pointeur sur RIEN.
Donc dans le meilleur des cas, ça plante :)

Essaye ça pour te convaincre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include<stdio.h> #include<stdlib.h> #include<string.h> int main(int argc, char *argv[]) { char *str1 = ""; char *str2 = NULL; printf("%s !!\n",(strcmp(str1,"")==0)?"Youhou":"Bouarf"); printf("%s !!\n",(strcmp(str2,"")==0)?"Youhou":"Bouarf"); return EXIT_SUCCESS; }
Citation:

Envoyé par lucas-84

Sinon, j'ai créé un tableau de chaînes de caractère, path, qui, en path[0], contient le premier argument de l'utilisateur, en path[1] le deuxième (pour la fonction copy_file), etc.

Vas tu modifier les chemins pendant l'exécution du programme ?
Si non, pourquoi les recopier ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include<stdio.h> #include<stdlib.h> #include<string.h> int main(int argc, char *argv[]) { char *str[2]; str[0] = argv[1]; str[1] = argv[2]; printf("%s - %s\n", str[0], str[1]); return EXIT_SUCCESS; }
Citation:

Envoyé par lucas-84

Sinon, je pensais prendre une orientation plus 'shell' si l'utilisateur n'entrait pas d'argument. Au lieu de faire un menu, pourquoi ne pas recoder un mini-shell contenant uniquement les fonctionnalités de création, de lecture, d'écriture et de copie ? (voire d'autres fonctions ultérieurement). J'intégrerais ainsi un système de man (Unixiens, vous me suivez 8-) ) qui permettrait à l'utilisateur de savoir quelles sont les commandes dont il dispose.

Très bonne idée oui ^^

30/08/2011, 09h48
lucas-84

Citation:

Il y a une très grosse différence entre "" et NULL.
Le premier indique que c'est une chaine de un caractère contenant le mot vide (\0)
Le deuxième est un pointeur sur RIEN.

D'accord, mais ce que je comprends pas, c'est comment les paramètres peuvent être NULL...

Citation:

Vas tu modifier les chemins pendant l'exécution du programme ?
Si non, pourquoi les recopier ?

C'est vrai.:lol:

J'ai actuellement un SEGFAULT quand j'exécute, mais je pense que c'est à cause des char*. Quand je les remplace par un char const * const, j'ai pleins d'erreurs. Je vais corriger ça, et après je poste un nouveau code.

Edit : en fait, je galère beaucoup avec ce char*[], je m’emmêle les pinceaux et je n'arrive pas à les passer en paramètre, ni à les modifier...

Citation:

Envoyé par lucas-84

D'accord, mais ce que je comprends pas, c'est comment les paramètres peuvent être NULL...

Dans ton utilisation non,
Mais si tu considères que ton module "file.c" peut être utilisé par des développeurs extérieurs, alors ils pourront très bien écrire :

Code:

copy_file(NULL, NULL);

Ça n'a strictement aucun intérêt pour ce cas de figure,
Mais c'est important de savoir si tu veux un module 100% sécurisé ou non
(à savoir que les tests ralentissent le programme ^^)

Citation:

Envoyé par lucas-84

J'ai actuellement un SEGFAULT quand j'exécute

Ton erreur de segmentation vient du pointeur "optind",
En fait, lorsque getopt traite une option, il avance l'index optind,
Pour récupérer un argument supplémentaire, je t'ai fait faire un saut d'index,
Mais ce saut s'effectue à la fin du traitement :
Code:

1 2 3 4 int i = 0; printf("%d\n", i++); // 0 printf("%d\n", ++i); // 2
Donc, lorsque tu écris :
Code:

1 2 3 if(option == 'd' && (strlen(argv[optind++]) <= MAX_LEN)) strncpy(str[1], argv[optind++], strlen(argv[optind++]));
Tu sors du nombre des arguments.
Réécrivons ce code en expansé :
Code:

1 2 3 4 5 6 7 8 9 10 11 char *src; int size; if(option == 'd' && (strlen(argv[optind++]) <= MAX_LEN)) { optind += 1; src = argv[optind]; size = strlen(argv[optind]); optind += 2; strncpy(str[1], src, size); }
ou :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 char *src; int size; if(option == 'd' && (strlen(argv[optind++]) <= MAX_LEN)) { optind += 1; size = strlen(argv[optind]); optind += 1; src = argv[optind]; optind += 1; strncpy(str[1], src, size); }
Tout dépend l'ordre d'exécution des arguments.

Pour l'utilisation de const,
Ce mot clé est un peu particulier,
En général j'évite de m'en servir car il est assez problématique,
Et pour la quasi totalité des gens il ne sert qu'à montrer qu'une valeur ne sera pas modifiée.
Alors que ça implique beaucoup plus de chose Oo

Voir 40 message(s) de cette discussion en une page