Scanf démythifiée

La fonction applique le filtre décrivant le format (la chaîne de caractères), sur le flux entrant.
Pour chaque conversion réussie, scanf place l'objet converti dans l'espace pointé par le pointeur associé. Aucune vérification n'est faite quant à la validité de ces pointeurs, de même que, dans le cas de saisie de chaîne de caractères (ou de séquence de caractères), aucun contrôle sur le rapport entre les quantités « espace alloué » / « taille de la saisie » : si le programmeur ne fait pas ces contrôles lui-même, les risques de buffer overflow sont élevés.

C'est là aussi une des subtilités du fonctionnement de scanf qu'il faut connaître, surtout si l'on souhaite en faire une utilisation poussée (i.e. sécurisée).

Tout d'abord, le cas particulier dont je vais vous parler concerne uniquement le cas du formateur '%c' (ainsi que celui des expressions rationnelles, mais le fonctionnement par rapport à ce cas particulier est le même…)

Par défaut, scanf supprime les espaces précédant ce qui peut convenir au formateur. Mais dans le cas du '%c', elle ne le fait pas, ce qui fait que les espaces peuvent « compter réellement » lorsque l'on a précisé une taille de saisie par exemple…
Le concept est peut-être un peu nébuleux, mais en pratique, c'est très simple… ;-)

Imaginons que je veuille récupérer 10 caractères sur l'entrée standard.

Je déclare un tableau de taille suffisante (i.e. permettant de mettre un terminateur de chaîne « manuellement » : on a vu que dans le cas du '%c', un caractère '\0' final n'était pas ajouté par scanf, au contraire du '%s')

char tab[11] = {0}; /* en l'initialisant à zéro, je mets le
                '\0' final directement...*/

Je récupère les 10 caractères naïvement… Et j'affiche le résultat.

scanf("%10c", tab); /* récupération */
printf("lu : %s", tab);

Et je fais la saisie suivante (entre guillemets qui ne font, eux, pas partie de la saisie)

      "azertyuiop" puis <Enter>

On obtient :

      "lu : azertyuiop"

Jusque là, tout va bien…
Mais imaginons un utilisateur farceur…

      "     azertyuiop"  puis Enter

Il y a cinq espaces avant la saisie qui nous intéresse.
Et on obtient :

      "lu : '     azert'"

Les blancs n'ont pas été enlevés. Et c'est gênant.

Remarque
On voit bien, une fois de plus, que les formateurs ne sont pas à employer à la légère : leur utilisation génère des résultats complètement différents.
On ne peut donc intervertir '%c' et '%s' sans qu'il y ait de conséquences.



Rappel

Malgré cela, que faire pour passer outre ce comportement qui peut fausser les exécutions des programmes. Il « suffit » de faire précéder le formateur '%10c' d'un espace, pour dire explicitement à scanf de réduire les espaces en tête.
On doit donc mettre ' %10c'.
Vérifions :

scanf(" %10c", tab);

Saisie :

      '     azertyuiop'  (cinq espaces précédant la saisie effective)

Donne :

      'lu : azertyuiop'

Les espaces ont bien été supprimés.

Note
On voit souvent les débutants utiliser à tort et à travers les espaces dans les chaînes de formatage. On voit bien à travers cet exemple que leur présence n'est pas innocente, et peut influer sur le comportement de la fonction.
Vigilance donc dans l'utilisation abusive d'espaces, que ce soit dans la chaîne de formatage, ou lors de la prise en compte des saisies utilisateur !!

Tout d'abord, il va sans dire que le paragraphe précédent n'a pas été écrit inutilement, et il faut bien avoir compris les subtilités d'espaces avec scanf. Tout peut être fait selon nos désirs, mais encore faut-il savoir clairement ce que l'on veut. Je considère donc tout ce qui a été dit précédemment comme acquis.

Importance du contrôle de la taille mémoire▲

char tab[80];

#define TAILLE 80
<...>
char tab[TAILLE+1] = {0}; /* +1 pour le caractère terminal */

#define xstr(s) str(s)
#define str(s) #s

scanf("%"xstr(TAILLE)"s", tab);

scanf("%""80""s", tab);

scanf("%80s", tab);

size_t taille;
<...>
taille = 80;

char *tab = calloc(taille, sizeof *tab);
/* ne pas oublier de tester le retour de la fonction calloc... */

int t_format = 81;
char *format = calloc(t_format, sizeof *format);
/* tester le retour de calloc... */

snprintf(format, t_format, "%%%ds", taille);

Récupération d'une ligne entière▲

char tab[81] = {0};
scanf(" %80[abcdefghijklmnopqrstuvwxyz]", tab);

scanf(" %80[a-zA-Z]", tab);

      'HellOWorLd'

char tab[81] = {0};
char c;

if (scanf("%80[^\n]", tab) == 1) {
    /* saisie reussie */
    if ( (c = getchar()) != '\n') {
        /* saisie trop longue */

    }

}
else{
    /* echec de la saisie */
    
}

int c;
while ( ((c = getchar()) != '\n') && c != EOF)
{
}

On l'a vu dans le paragraphe précédent, l'échec (ou non !) de scanf lors d'une saisie est susceptible de laisser des caractères sur le flux entrant. Ce comportement est particulièrement gênant en cas d'utilisation de scanf à l'intérieur d'une boucle.

Il existe une expression rationnelle que l'on peut rajouter à la fin de celle(s) qui nous intéresse(nt). On va utiliser le spécificateur '*' pour indiquer que l'on ignore le résultat.

Ainsi, vider le flux reviendra à dire : « je valide tout caractère différent de '

' (avec '^'), et je me fiche du résultat (avec '*') ». Cela donne :

scanf("%*[^\n]");

On ne précise pas de pointeur, puisque l'on « jette » le résultat. Par contre, il reste encore et toujours le même caractère dans le flux entrant : ce satané '\n'. On lui règle son compte avec un 'getchar' bien senti.
Vider le flux entrant avec scanf revient finalement à :

scanf("%*[^\n]");
getchar();

Lors de l'utilisation dans une boucle, si, par exemple, on souhaite que l'utilisateur entre un nombre, et que l'on veuille le lui redemander tant que ce n'est pas le cas, le code serait le suivant :

#include <stdio.h>

int main(void){

  int nombre = 0;
  int ok = 0;
  int retour;

  printf("saisissez un nombre :\n");
  while (!ok){

    retour = scanf("%d%*[^\n]", &nombre);
    printf("retour : %d\n", retour);
    if ( !retour ){
      /* erreur de saisie, on vide le flux */
      int c;
      while ( ((c = getchar()) != '\n') && c != EOF);

      printf("on vous a demande de saisir un nombre\n");
      printf("veuillez recommencer :\n");
    }
    else {
      /* réussite de la saisie */
      getchar(); /* on enleve le '\n' restant */

      printf("saisie acceptee\n");
      ok = 1;  /* sort de la boucle */
    }

  }

  return 0;
}

En fait, si la saisie échoue (valeur de retour de scanf égale à zéro dans le cas présent), il faut vider explicitement stdin (avec getchar par exemple, mais on pourrait utiliser scanf comme vu plus haut ;-).
Par contre, en cas de réussite, l'ER suivante : '%*[^\n]' permet de supprimer tout caractère restant. C'est le cas si, par exemple, on a une saisie du genre :

        '1234azertyuiop poiuytreza'

Le nombre 1234 sera récupéré, et le reste du flux purgé.

Par contre, en cas de réussite, il ne faut pas oublier d'enlever le '\n' restant…

Scanf retourne le nombre d'éléments assignés correctement. Ainsi, un retour de valeur zéro signifie qu'aucun élément n'a été assigné ; c'est le cas lorsque l'on entre une lettre alors que le formateur est '%d'.

Il faut noter le cas particulier que constitue l'utilisation de l'étoile '*', signifiant que l'on ignore le résultat. En effet, même si la conversion a réussi, comme rien n'a été affecté, elle ne sera pas comptabilisée.

Dans le cas suivant, si tout se passe bien, la valeur de retour de scanf sera 1 (et non 2) :

int a;
scanf("%d%*[^\n]", &a);

Imaginons maintenant que nous voulions récupérer certains éléments d'une saisie, et en passer d'autres.

Exemple :
« 123azerty456uiop789 »
Et on ne veut récupérer que les nombres aux extrémités, tout en vérifiant que la ligne suit le pattern suivant :

[nombre]~[lettres]~[nombre]~[lettres]~[nombre]

On peut imaginer de faire comme suit :

int a, b;
scanf("%d%*[a-z]%*[0-9]%*[a-z]%d", &a, &b);

• On récupère le premier entier.
• On vérifie sans assignement qu'il existe bien une suite de lettres (minuscules).
• On vérifie sans assignement qu'il existe bien une suite de chiffres.
• On vérifie sans assignement qu'il existe bien une suite de lettres (minuscules).
• On récupère le second entier.

On a vu que si scanf réussi, on aura comme valeur de retour 2 (puisqu'on assigne deux éléments).
Mais en cas d'échec, la valeur ne pourra être que 0 (rien d'assigné) ou 1 (premier entier).

Si l'on veut faire une gestion fine des erreurs, voire reprendre sur ces mêmes erreurs, on ne dispose pas assez d'informations pour savoir ou exactement scanf a échouée :
Est-ce à cause :

• des symboles ou des majuscules dans la première séquence de lettres ?
• pas de seconde séquence de chiffre ?
• des symboles ou des majuscules dans la seconde séquence de lettres ?

Nous allons donc aborder le dernier formateur utile de scanf : le formateur '%n'.
Ce formateur nous permet de connaître le nombre de caractères lus par scanf au moment de l'assignement. Le pointeur associé est un pointeur sur int.

Note :
Le nombre de caractères lus est différent du nombre d'assignations réalisées.

Reprenons donc l'exemple ci-avant. Si l'on veut connaître où peut avoir echoué scanf, il suffit de déclarer quelques variables supplémentaires.
Ainsi :

int a = 0;
int  b = 0;
int seq_1_lettres = 0;
int seq_chiffre = 0;

scanf("%d%*[a-z]%n%*[0-9]%n%*[a-z]%d", &a, &seq_1_lettres, &seq_chiffre, &b);

On peut donc tester le retour de scanf de la façon suivante :

if(!b) {
  /* b n'a pas ete assigne, on en deduit un echec de scanf */
  if(!a){
    /* echec complet de scanf */
          ...
  } else {
    /* au moins a est correct */
    if (!seq_1_lettres){
      /* c'est la sequence de lettres qui n'est pas passee */
         ....
    } else if (!seq_chiffre) {
      /* la sequence de chiffres a plante... */
      ....
    }
  }

} else {
  /* b a ete correctement rempli, c'est donc que scanf s'est correctement deroule jusqu'au bout*/
    ....
}

.....