Discussion :

[flo557]

Bonjour,

Je viens demander de l'aide car je ne trouve pas de solution seul à mon "problème". J'ai écrit un programme qui fonctionne du coup je peaufine les détails. Mon programme vise à effectuer un certain nombre d'opérations de flou sur une image. Quand je lance le programme sur cygwin, je demande en 3ème argument le nombre d'itérations à effectuer (cas que je ne peux changer, le programme est demandé ainsi).

Du coup voici mes variables déclarés et ce que j'ai fait pour le moment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 // Définition des différentes variables + images
  image im_ori, im_res;
  int x,y,h,l,a,i;
 
...
 
 // Vérification du nombre d'itérations à effectuer
      const char *s = (argv[3]);
      test_entier(s);
 
      sscanf(argv[3], "%d", &a);
 
    if (a < 0) {
      printf("Le nombre d'itérations saisi est négatif !\n");
      usage(argv[0]);
    } else if (a == 0) {
      printf("Aucune opération de flou effectuée.\n");
      usage(argv[0]);
    }
 
    if (a == (int)(a)) {
    } else {
    usage(argv[0]);
    }"
 
La fonction test_entier :
 
if(sscanf(s,"%d",&x) == 1){
    }
    else{
      printf("%s n'est pas un chiffre !\n",s);
      exit(1);
    }

C'est à la fin qu'il y a un problème. J'ai bien réussi à bloquer le programme si le nombre est négatif, s'il commence par une lettre (d, d85 par exemple) mais je ne sais pas faire :
- stopper le programme si on tape 10.5
- stopper le programme si on tape 58ef

Des idées ?

Merci d'avance ! (je suis débutant en C)

[Elijha]

Bonjour,

Premièrement tu te dois de tester le retour du sscanf. Si argv[3] est une chaine de caractères non numérique, sscanf doit te retourner 0, car elle n'a pas réussie à faire une conversion.

Deuxièmement, comme tu passes un format "%d" à la fonction sscanf, elle te retournera que la valeur entière du nombre décimal ou de la première valeur numérique.
Exemples

1. pour "10.5" --> sscanf(...) = 1 --> a = 10
2. pour "58bf" --> sscanf(...) = 1 --> a = 58
3. pour "tt87ff" --> sscanf(...) = 0 --> Erreur de paramètre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    // 1. Tester si argv[3] est renseigné
    if(argv[3]==NULL) {
        printf("Manque le paramètre n°3 !\n") ;
        return EXIT_FAILURE ;
    }
    // 2. Récupère la valeur numérique ENTIERE
    else if(sscanf(argv[3], "%d", &a)==1) {
        // Test la valeur négative ou nulle
        if(a<0 || a==0) {
            printf("Paramètre n°3 faux !\n") ;
            return EXIT_FAILURE ;
        }
        printf("Nombre d'itérations = %d\n", a) ;
    }
    // 3. Si erreur de paramètre n°3 si différent d'une valeur numérique
    else {
        printf("Erreur de paramètre n°3 ! \n") ;
        return EXIT_FAILURE ;
    }

Si tu veux un filtrage plus poussé et arrêter le programme car les paramètres ne sont pas correctes, alors il te faut utiliser d'autres fonctions complémentaires (les tiennes ou celles déjà existante).

Bonne continuation.

[BufferBob]

salut,

effectivement les regex qu'on peut passer dans la chaine de formatage de sscanf sont pas suffisantes pour valider l'intégralité de la chaine, à partir du moment où la fonction trouve au moins une occurrence elle va renvoyer ok

perso j'aurais limite tendance à mettre sscanf de coté et faire une fonction maison, le principe est simple; le premier caractère de la chaine peut éventuellement être un signe -, tout le reste doit obligatoirement compris entre 0 et 9 inclus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int _isnum (char *s) {
   int i = 0;
   do {
      if (!(s[i] >= '0' && s[i] <= '9') /* si le caractere n'est pas compris entre 0 et 9 */
       && !(s[i] == '-' && i == 0))     /* et que ce n'est pas non plus un signe '-' en debut de chaine */
         return 1; /* alors on sort : ce n'est pas un nombre */
   } while (s[++i]);
   return 0; /* arrivé ici, c'est que tout s'est bien déroulé dans la boucle, donc la chaine est un nombre */
}

[grim7reaper]

effectivement les regex qu'on peut passer dans la chaine de formatage de sscanf sont pas suffisantes pour valider l'intégralité de la chaine

La chaîne de format de scanf n’a rien à voir avec les regexp…

perso j'aurais limite tendance à mettre sscanf de coté

Moi aussi, surtout que si le nombre en entrée est trop grand et fait un overflow c’est un undefined behavior.

[…]If this object does not have an appropriate type, or if the result of the conversion cannot be represented in the object, the behavior is undefined.

On notera que l’implementation de la glibc positionne errno à ERANGE mais ça n’a rien de standard.

faire une fonction maison

Perso, j’utiliserait fgets + strtol (qui permet bien de détecter et gérer les différents cas d’erreurs), pas besoin de réinventer la roue en moins bien…

[BufferBob]

La chaîne de format de scanf n’a rien à voir avec les regexp…

c'est un abus de langage c'est vrai, j'aurais sans doute du parler des possibilités offertes par les spécificateurs de format de la chaine de formatage ou similaire, au temps pour moi

Perso, j’utiliserait fgets + strtol (...), pas besoin de réinventer la roue en moins bien…

en plus d'être capable de faire bien mieux n'hésite pas si le coeur t'en dis à donner un exemple d'implémentation et/ou des explications supplémentaires, il semblerait que ce soit de nature à aider flo557

je répond d'ailleurs ici à la question qu'il me posait par message privé plus tôt dans la journée :

si j'utilise ta fonction avec mon argument, dans le main je peux mettre _instnum(argv[3]) ?

oui (il suffisait de tester ^^)

[flo557]

Bonsoir,

Merci à tous pour vos commentaires, j'ai un peu avancé sur le sujet mais ça bloque toujours... Voici le code (en partie sinon c'est long) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int _isnum (char *s) {
   int j = 0;
   do {
      if (!(s[j]) >= '0'){ /* si le caractere n'est pas compris entre 0 et 9 */
         printf("Ceci n'est pas un nombre !");
		 usage(); /* alors on sort : ce n'est pas un nombre */
	}else if ((s[j]) <= '9'){
		 printf("test");
		 usage();
		 }
   } while (s[++j]);
   return 0; /* arrivé ici, c'est que tout s'est bien déroulé dans la boucle, donc la chaine est un nombre */
  return(0);
}

J'ai enlevé le && du code de BufferBob en essayant || à la place, ça n'a pas fonctionné ni en séparant les conditions comme ci-dessus... Savez-vous d'où provient mon problème ?

Merci par avance pour votre temps

[BufferBob]

salut,

j'ai un peu avancé sur le sujet mais ça bloque toujours...

c'est à dire ?

J'ai enlevé le && du code de BufferBob en essayant || à la place

pourquoi ?

Savez-vous d'où provient mon problème ?

en partie du fait que tu modifies la fonction que je t'ai donné et qui fonctionne pour en faire une fonction qui n'a ni queue ni tête

j'avais cru comprendre que tu cherchais une fonction qui détermine si une chaine est composée uniquement de chiffres ou non, avec éventuellement un signe négatif au début, manifestement ce ne doit pas être le cas, qu'est-ce que tu cherches à faire exactement (et/ou qu'est-ce qui ne convenait pas dans la fonction que je t'ai donné) ?

[ternel]

Ta fonction fait deux choses, vérifier que c'est un nombre, et afficher un message si ce n'est pas le cas.
C'est dommage.

Il vaut mieux avoir deux fonctions, et les utiliser toutes deux dans une autre de plus haut niveau (d'abstraction), comme main() par exemple.

[grim7reaper]

en plus d'être capable de faire bien mieux n'hésite pas si le coeur t'en dis à donner un exemple d'implémentation et/ou des explications supplémentaires, il semblerait que ce soit de nature à aider flo557

Pas de problème.

Voilà une fonction qui lit un entier strictement supérieur à zéro dans une chaîne :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static int read_int(const char *input,
                    int min_value, int max_value,
                    int* number, const char** error)
{
    char *end;
    long  ret;
 
    assert(input  != NULL);
    assert(min_value <= max_value);
    assert(number != NULL);
    assert(error  != NULL);
 
    errno = 0;
 
    ret = strtol(input, &end, 10);
    if(end != input) {
        if((ret == LONG_MAX && errno == ERANGE) || (ret > max_value)) {
            *error = "the input number is too big";
            return -1;
        }
        if((ret == LONG_MIN && errno == ERANGE) || (ret < min_value)) {
            *error = "the input number is too small";
            return -1;
        }
        if (*end != '\0') {
            *error = "the input contains more than a number";
            return -1;
        }
        *error  = "";
        *number = (int)ret;
    } else {
        *error = "the input is not a number";
        return -1;
    }
 
    return 0;
}
 
int main(void)
{
    int n;
    const char* err;
 
    assert(read_int("1",          1, INT_MAX, &n, &err) ==  0);
    assert(read_int("42",         1, INT_MAX, &n, &err) ==  0);
    assert(read_int("2147483647", 1, INT_MAX, &n, &err) ==  0);
 
    assert(read_int("",           1, INT_MAX, &n, &err) == -1);
    assert(read_int("d",          1, INT_MAX, &n, &err) == -1);
    assert(read_int("d85",        1, INT_MAX, &n, &err) == -1);
    assert(read_int("10.5",       1, INT_MAX, &n, &err) == -1);
    assert(read_int("58ef",       1, INT_MAX, &n, &err) == -1);
    assert(read_int("0",          1, INT_MAX, &n, &err) == -1);
    assert(read_int("-3",         1, INT_MAX, &n, &err) == -1);
    assert(read_int("2147483648", 1, INT_MAX, &n, &err) == -1);
 
    return 0;
}

La fonction échoue (et donc renvoie -1 et un message d’erreur est fourni dans error) si :
- la chaîne est vide
- la chaîne ne contient pas un nombre entier ("d", "d85", …).
- la chaîne contient un entier plus autre chose ("10.5", "58ef", …).
- la chaîne contient un entier mais il n’est pas inclus dans [min_value, max_value].

Apparemment, tu récupères ton argument à partir de argv, si tu voulais l‘avoir à partir de stdin, tu pourrais faire un truc du genre :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
char buf[128];
char *newline;
int n;
 
if (fgets(&buf, sizeof(buf), fp) == NULL) {
    fputs("I/O error: cannot read input", stderr);
}
fgets(buf, sizeof(buf), stdin);
newline = strchr(buf, '\n');
if (newline) {
    *newline = '\0';
}

Puis appeler read_int sur la variable buf.

[flo557]

Alors avec la fonction _isnum j'ai bien mon flou qui se fait quelque soit la valeur de l'argument entrée : 85, -9, d4, 8f. En fait, il faudrait que l'argument qui correspond au nombre d'itérations à faire soit un entier positif non nul : 1, 2, 3, 4, 5, ... c'est tout.

Si qqn peut m'éclairer... Et je suis aussi preneur de solutions pour optimiser mon programme qui marche en l'état Notamment pour toutes les variables points, si une solution existe.

Encore merci à tous pour votre temps, vos conseils et votre sympathie !

[BufferBob]

je n'ai pas lu tout le code (de toutes façons sans la libimage on ne pourra pas compiler à priori)
pour le moins, la fonction que je t'ai donné :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int _isnum (char *s) {
   int i = 0;
   do {
      if (!(s[i] >= '0' && s[i] <= '9') /* si le caractere n'est pas compris entre 0 et 9 */
       && !(s[i] == '-' && i == 0))     /* et que ce n'est pas non plus un signe '-' en debut de chaine */
         return 1; /* alors on sort : ce n'est pas un nombre */
   } while (s[++i]);
   return 0; /* arrivé ici, c'est que tout s'est bien déroulé dans la boucle, donc la chaine est un nombre */
}

ce que tu as modifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
int _isnum (char *s) {
   int i = 0;
   do {
      if (!(s[i] >= '0' && s[i] <= '9') /* si le caractere n'est pas compris entre 0 et 9 */
         printf("Ceci n'est pas un nombre !");
         return 1; /* alors on sort : ce n'est pas un nombre */
   } while (s[++i]);
   printf("test");
   return 0; /* arrivé ici, c'est que tout s'est bien déroulé dans la boucle, donc la chaine est un nombre */
}

ce qu'il manque pour que ça marche correctement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int _isnum (char *s) {
   int i = 0;
   do {
      if (!(s[i] >= '0' && s[i] <= '9') { /* si le caractere n'est pas compris entre 0 et 9 */
         printf("Ceci n'est pas un nombre !");
         return 1; /* alors on sort : ce n'est pas un nombre */
      }
   } while (s[++i]);
   printf("test");
   return 0; /* arrivé ici, c'est que tout s'est bien déroulé dans la boucle, donc la chaine est un nombre */
}

les accolades ça fait quand même partie des bases du langage ^^
donc si je comprends bien la gestion du signe te gonflait et tu voulais uniquement vérifier si les nombres était bien positifs (ou nuls ?)

ma fonction est peut-être pas top ou trop difficile à appréhender, grim7reaper t'a fait une jolie fonction qui marche du tonnerre, ça vaut peut-être le coup d'y jeter un oeil, d'autant qu'au delà de sa compréhension elle est facile à utiliser.

[flo557]

Merci à tous : problème résoluuuuuuuuuuuuu !!!

[sambia39]

Bonjour
Je suis un peu vieux jeux mais est-il possible de façon astucieuse d'écrire le code sources ci-dessous.
le code est légèrement écrit à la hâte donc par forcément propre et susceptible de comporter des erreurs.
à bientôt.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdio.h>
#include <stdlib.h>
 
/*	Fonction affichage 
*	du message d'erreur
*	de saisie	*/
int f_er_stdin( void ){
	int i = 0;
	while( (i = getchar() != ('\n') ) && ( (EOF) != i ) )
		printf(">> Veuillez entrer que des nombres positif\n");
	return ( 0 );
}
 
/*	Fonction de saisie qui
*	retourne la valeur absolue 
*	du nombre saisie*/
unsigned int f_Get_Stdin( void ){
 
	int ret_scn = 0;
	short loop = 0;
	unsigned reslt = 0;
 
	while( (0) == loop ){
		ret_scn = scanf( "%d%*[^\n]",&reslt );
		loop = ( (0) == ret_scn ) ? f_er_stdin() : 1;  
	}
	return ( abs(reslt) );
}
 
/*	Fonction principale	*/
int main( void ){
 
	unsigned int i = 0;
	printf("Saisir un nombre\t:");
 
	i = f_Get_Stdin();
	printf(">>\t%d\n", i );
	return ( EXIT_SUCCESS );
}