Vérifier si un entier introduit par scanf() est vraiment de type int

Version imprimable

08/04/2009, 07h23
linuxeur

Vérifier si un entier introduit par scanf() est vraiment de type int

Bonjour,

Je cherche une fonction en C sous Linux qui permet de vérifier si un entier entrée par clavier (par scanf() ou autre fonction) est vraiment de type int (entier).

Merci.

bonjour,

si le texte est saisi dans une chaîne de caractères, vous pouvez faire un sscanf de ce type :
Code:

1 2 3 4 5 6 7 8 9 10 char *text = ...; int entier = 0; char dummy; if (sscanf(text, "%d%c", &entier, &dummy)==1) { // OK (un entier suivi de rien) } else { // KO (pas un entier ou un entier suivi d'autre chose }

08/04/2009, 10h52
Sniper Hawk

apres la lecture faire le test de chaque element de la chaine par isdigit(int)

Bonsoir.
Je vais reformuler ma question, il y a des bibliothèques externes à la bibliothèque standard du du langage C/C++, tels que la bibliothèque raknet (http://www.jenkinssoftware.com), pour la programmation réseaux qui permet d'éviter l'utilisation directe des socketes, ou la bibliothèque SDL pour la programmation graphique, ... etc. je cherche à éviter l'utilisation de scanf(), isdigit(), ...etc. voici un pseudo-code de mon problème:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main() { int nombre; printf(" veuillez introduire un nombre:"); scanf("%d", & nombre); /* vérification si le nombre introduit par scanf() est vraiment un nombre entier, c'est ici que réside mon problème */ return 0; }
Y a-t-il pas une bibliothèque qui me permet de faire cette vérification son utilisation des outils classiques ou standards ?

Voici un code qui test tout dabord si le nombre est à virgule ou non; puis, dans le cas ou ce n'est pas un nombre a virgule s'il contient (commence plus précisement) par des caractères.
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 #include <stdio.h> #include <stdlib.h> #include <string.h> int main(void) { char nombre[50] = ""; int num = 0; scanf("%49s", nombre); if(strchr(nombre, '.') != 0) puts("nb decimal"); else { num = strtol(nombre, NULL, 10); if(0 == num) puts("contient caractere(s)"); else puts("ok"); } return 0; }
Poses des questions en cas d'incompréhension.

08/04/2009, 19h29
linuxeur

Merci beaucoup _concept_, ça a marché très bien pour moi, je vais l'adopter tel qu'il est, car c'est ce que je cherché exactement, il va régler mon problème.

Ce code a marché pour les cas suivants :
10.52 ->nb decimal; bien
10->OK; bien
a22->contient caractere(s); bien

mais pour le cas particulier: 22a->ok; en ajoutant: printf("num = %d", num); à la fin du code il affiche: num = 22. Ce n'est pas grave _concept_ car le code m'arrange tel qu'il est.

Merci
08/04/2009, 20h39
orfix
Citation:

Envoyé par linuxeur

Ce code a marché pour les cas suivants :
10.52 ->nb decimal; bien
10->OK; bien
a22->contient caractere(s); bien

Voilà ce que j'obtiens moi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 1234......... nb decimal ................................ nb decimal 123ABCDEFGHIJKL45 ok 1HOMER ok .HOMER. nb decimal
08/04/2009, 20h42
_concept_

Oui dans un scanf() qui attend une saisie de nombre, si tu insères des chiffres puis au moins un caractère il ne considèrera que la série de chiffre avant ce caractère.
J'ai pensé que dans ton cas ça aurait peu d'importance, de plus l'implémentation pour vérifier si la chaîne contient au moins un caractère est un peu lourde (pas compliquée pour autant ;) )
08/04/2009, 20h58
_concept_

A "ssmario2" -> Tu as raison pour le sytème des points ça n'est pas très sécurié... Mais je pense qu'en remplaçant la condition par :

Code:

if(strchr(nombre, '.') == strrchr(nombre, '.'))

ça élimine le problème.
Pour les nombres contenant des caractères ailleurs qu'en début de chaîne; c'est, comme dit plus haut, un choix de ne pas signaler une erreur car il ne seront de toute façon pas pris en compte.
Les repérer, les enlever du tableau et obtenir un nombre correct rendrait le code posté bien plus compliqué et serait de peu d'utiliter au PO.
Amicalement.

Dans ce cas pourquoi ne pas utiliser strtod qui fait cela très bien ?

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
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
	char const *str[] = { "1234.5",
			      "123",
			      "123.",
			      "123.123.",
			      "X123",
			      "123X",
			      "1X23",
			      "123e32",
			      "-123",
			      "+123E-3"
	};
	size_t i;
 
	for( i=0 ; i<sizeof str/sizeof *str; i++)
	{
		char *end;
		double num = strtod(str[i], &end);
		/* Je ne sais pas si il est utile de tester aussi 
		 * la valeur de `errno` 
		 */
		if( end!=NULL && *end=='\0' )
		{
			printf("%-9s : %g\n",str[i],num);
		}
		else
		{
			printf("%-9s : Erreur\n",str[i]);
		}
	}
	return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
1234.5    : 1234.5
123       : 123
123.      : 123
123.123.  : Erreur
X123      : Erreur
123X      : Erreur
1X23      : Erreur
123e32    : 1.23e+34
-123      : -123
+123E-3   : 0.123

Citation:

Envoyé par ssmario2

Dans ce cas pourquoi ne pas utiliser strtod qui fait cela très bien ?

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
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
	char const *str[] = { "1234.5",
			      "123",
			      "123.",
			      "123.123.",
			      "X123",
			      "123X",
			      "1X23",
			      "123e32",
			      "-123",
			      "+123E-3"
	};
	size_t i;
 
	for( i=0 ; i<sizeof str/sizeof *str; i++)
	{
		char *end;
		double num = strtod(str[i], &end);
		/* Je ne sais pas si il est utile de tester aussi 
		 * la valeur de `errno` 
		 */
		if( end!=NULL && *end=='\0' )
		{
			printf("%-9s : %g\n",str[i],num);
		}
		else
		{
			printf("%-9s : Erreur\n",str[i]);
		}
	}
	return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
1234.5    : 1234.5
123       : 123
123.      : 123
123.123.  : Erreur
X123      : Erreur
123X      : Erreur
1X23      : Erreur
123e32    : 1.23e+34
-123      : -123
+123E-3   : 0.123

A la base, il était question d'entier, pas de réel :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
 
static int get_int(int * result)
{
  int  tmp = 0;
  char dummy[2];
  int  const errno_backup = errno;
  int  ret = 0;
 
  errno = 0;
 
  if(scanf("%d%1[^\n]", &tmp, dummy) == 1)
  {
    if(errno == 0)
    {
      *result = tmp;
    }
    else
    {
      ret = errno;
    }
  }
  else
  {
    ret = EINVAL;
  }
 
  scanf("%*[^\n]"), getchar();
  errno = errno_backup;
  return ret;
}
 
int main(void)
{
  unsigned i = 0;
 
  while(i++ != 5)
  {
    int num = 0;
    int ret = get_int(&num);
 
    if(ret == 0)
    {
      printf("num = %d\n", num);
    }
    else
    {
      printf("erreur = %s\n", strerror(ret));
    }
  }
 
  return 0;
}

09/04/2009, 11h57
Emmanuel Delahaye
Citation:

Envoyé par linuxeur

Je cherche une fonction en C sous Linux qui permet de vérifier si un entier entrée par clavier (par scanf() ou autre fonction) est vraiment de type int (entier).

Si tu mets une valeur dans un int, elle est de type int, cest certain.

Ta vrai question, je suppose, est plutôt :

"Est-ce que telle chaine de caractères représente bien un entier ?"
- Qu'appelle-tu 'entier' ?
- Y'a-t-il une valeur minimale ? Maximale ? La valeur peu elle être signée ?
- Est-ce que 123. ou 123.0 sont des entiers ?
- Est-ce que le format hexadécimal est accepté : 0x123a ?
- Est-ce que le format octal est accepté : 0123 ?
Il faut être précis dans la définition, ça permet d'écrire du code qui fonctionne...

Bonsoir tout le monde,

voici une fonction que j'ai programmée et qui vérifie si un entier introduit par clavier est vraiment un 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
35
36
37
38
39
 
#include <stdio.h>
#include <string.h>
 
int estint(char *str)  /* fonction de verification d'un entier */
{
	int i = 0;
 
	for(i = 0; i < strlen(str); i++)
	{
		if((str[i] < 48) || (str[i] > 57))
			return -1;
	}
	return 0;
}
 
int main(int argc,char **argv)
{
	int entier = 0;
 
	if (argc != 2)
	{
		printf("Untiliser: ./estint <entier>\n");
		printf("Exemple:   ./estint 13\n");
		return -1;
	}
 
	if(estint(argv[1]) == -1)
	{
		printf("Entree un entier SVP\n");
		return -1;
	}
 
	entier = atoi(argv[1]); /* convertire du char ver int */
 
	printf("\n\nl'entier est |%d|.\n\n", entier);
 
	return 0;
}

Remarque : j'ai fait le test de ce programme sous Linux. :yaisse2:

Citation:

Envoyé par linuxeur

Bonsoir tout le monde,

voici une fonction que j'ai programmée et qui vérifie si un entier introduit par clavier est vraiment un 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
35
36
37
38
39
 
#include <stdio.h>
#include <string.h>
 
int estint(char *str)  /* fonction de verification d'un entier */
{
	int i = 0;
 
	for(i = 0; i < strlen(str); i++)
	{
		if((str[i] < 48) || (str[i] > 57))
			return -1;
	}
	return 0;
}
 
int main(int argc,char **argv)
{
	int entier = 0;
 
	if (argc != 2)
	{
		printf("Untiliser: ./estint <entier>\n");
		printf("Exemple:   ./estint 13\n");
		return -1;
	}
 
	if(estint(argv[1]) == -1)
	{
		printf("Entree un entier SVP\n");
		return -1;
	}
 
	entier = atoi(argv[1]); /* convertire du char ver int */
 
	printf("\n\nl'entier est |%d|.\n\n", entier);
 
	return 0;
}

Remarque : j'ai fait le test de ce programme sous Linux. :yaisse2:

Non portable ta fonction :

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
bool is_integer(char const *str)  /* en théorie, il faut éviter les identificateurs commençant par is */
{
   bool ret = false;
 
   if(str == NULL)
   {
      errno = EINVAL;
   }
   else
   {
      ret = true;
 
      for(size_t i = 0, length = strlen(str); i < length; i++)
      {
         if(!isdigit((unsigned char)str[i]))
         {
            ret = false;
            break;
         }
      }
   }
 
   return ret;
}

mais le mieux est encore d'utiliser la fonction que j'ai donné plus haut.