Max longueur de la chaîne à l'aide de scanf -> C ANSI

Je n'étais pas heureux avec l'une de ces solutions, donc j'ai plus amples recherches et découvert GNU GCC macro stringification

qui peut être utilisé comme:

#define XSTR(A) STR(A)
#define STR(A) #A
#define MAX_STR_LEN 100
scanf("%"XSTR(MAX_STR_LEN)"[^\n]s", sometext)

Peut-être VS2010 propose quelque chose de similaire?

Comme presque tout le monde le dit, il est préférable d'utiliser fgets(..., stdin) pour gérer ce problème.

Dans le lien suivant, j'ai proposé un coffre-fort et une technique correcte qui vous permettent de remplacer scanf() par une méthode plus sûre, par le biais d'un solide macro:

Une macro en toute sécurité remplace scanf()

La macro que j'ai proposé (travail compatible avec C99 compilateurs) est safe_scanf(), comme le montre le programme suivant:

#include <stdio.h>
#define safe_scanf(fmt, maxb, ...) { \
    char buffer[maxb+1] = { [maxb - 1] = '
#include <stdio.h>
#define safe_scanf(fmt, maxb, ...) { \
char buffer[maxb+1] = { [maxb - 1] = '\0' }; \
fgets(buffer, maxb+1, stdin); \
if ((buffer[maxb - 1] != '\0') && (buffer[maxb - 1] != '\n')) \
while(getchar() != '\n') \
; \
sscanf(buffer, fmt, __VA_ARGS__); \
}
#define MAXBUFF 20     
int main(void) {
int x; float f;      
safe_scanf("%d %g", MAXBUFF+1, &x, &f);
printf("Your input was: x == %d\t\t f == %g",  x, f);
return 0;
}  
' }; \
    fgets(buffer, maxb+1, stdin); \
    if ((buffer[maxb - 1] != '
#include <stdio.h>
#define safe_scanf(fmt, maxb, ...) { \
char buffer[maxb+1] = { [maxb - 1] = '\0' }; \
fgets(buffer, maxb+1, stdin); \
if ((buffer[maxb - 1] != '\0') && (buffer[maxb - 1] != '\n')) \
while(getchar() != '\n') \
; \
sscanf(buffer, fmt, __VA_ARGS__); \
}
#define MAXBUFF 20     
int main(void) {
int x; float f;      
safe_scanf("%d %g", MAXBUFF+1, &x, &f);
printf("Your input was: x == %d\t\t f == %g",  x, f);
return 0;
}  
') && (buffer[maxb - 1] != '\n')) \
        while(getchar() != '\n') \
           ; \
    sscanf(buffer, fmt, __VA_ARGS__); \
  }

#define MAXBUFF 20     

int main(void) {
   int x; float f;      
   safe_scanf("%d %g", MAXBUFF+1, &x, &f);
   printf("Your input was: x == %d\t\t f == %g",  x, f);
   return 0;
}  

Vous auriez à tune la valeur de MAXBUFF en fonction de vos besoins...

Bien que la macro safe_scanf() est assez solide,

il y a une certaine faiblesse dans l'utilisation de la macro approche:

Manque la vérification de type pour les paramètres, manque de "retour" des valeurs (qui se distingue peu de la "vraie" scanf() fonction, qui renvoie un int, avec de précieuses informations pour la vérification des erreurs), et ainsi de suite.

Tous les problèmes ont une solution, mais il fait partie d'un autre sujet...

Peut-être, plus exactement la solution consiste à définir une fonction my_scanf() avec un nombre variable de paramètres, en invoquant la stdarg.h bibliothèque, joint à une combinaison de fgets() et vsscanf(). Ici vous avez le code:

#include <stdio.h>
#include <stdarg.h>

int my_scanf(const char* fmt, const unsigned int maxbuff, ...) {
    va_list ptr;
    int ret;

    if (maxbuff <= 0)
       return EOF; /* Bad size for buffer[] */

    char buffer[maxbuff+1];
    buffer[maxbuff-1] = '
#include <stdio.h>
#include <stdarg.h>
int my_scanf(const char* fmt, const unsigned int maxbuff, ...) {
va_list ptr;
int ret;
if (maxbuff <= 0)
return EOF; /* Bad size for buffer[] */
char buffer[maxbuff+1];
buffer[maxbuff-1] = '\0';  /* Quick buffer cleaning... */
if (fgets(buffer, maxbuff+1, stdin) == NULL)
return EOF; /* Error detected */
else {
if ((buffer[maxbuff-1] != '\n') && (buffer[maxbuff-1] != '\0'))
/* Condition logically equivalent to:
fgets() has not reached an '\n'
*/
while (getchar() != '\n')
; /* "Flushing" stdin... */
va_start(ptr, maxbuff);
ret = vsscanf(buffer, fmt, ptr);
va_end(ptr);
return ret;
}    
}
#define MAXBUFF 20
int main(void) {
int x; 
float z;
int scanf_ret = my_scanf("%d %g", MAXBUFF, &x, &z);
printf("\nTest:\n x == %d\n z == %g\n scanfret == %d", x, z, scanf_ret);
getchar();   
return 0;   
}
';  /* Quick buffer cleaning... */

    if (fgets(buffer, maxbuff+1, stdin) == NULL)
       return EOF; /* Error detected */
    else {
        if ((buffer[maxbuff-1] != '\n') && (buffer[maxbuff-1] != '
#include <stdio.h>
#include <stdarg.h>
int my_scanf(const char* fmt, const unsigned int maxbuff, ...) {
va_list ptr;
int ret;
if (maxbuff <= 0)
return EOF; /* Bad size for buffer[] */
char buffer[maxbuff+1];
buffer[maxbuff-1] = '\0';  /* Quick buffer cleaning... */
if (fgets(buffer, maxbuff+1, stdin) == NULL)
return EOF; /* Error detected */
else {
if ((buffer[maxbuff-1] != '\n') && (buffer[maxbuff-1] != '\0'))
/* Condition logically equivalent to:
fgets() has not reached an '\n'
*/
while (getchar() != '\n')
; /* "Flushing" stdin... */
va_start(ptr, maxbuff);
ret = vsscanf(buffer, fmt, ptr);
va_end(ptr);
return ret;
}    
}
#define MAXBUFF 20
int main(void) {
int x; 
float z;
int scanf_ret = my_scanf("%d %g", MAXBUFF, &x, &z);
printf("\nTest:\n x == %d\n z == %g\n scanfret == %d", x, z, scanf_ret);
getchar();   
return 0;   
}
'))
            /* Condition logically equivalent to:
                   fgets() has not reached an '\n'
            */
            while (getchar() != '\n')
               ; /* "Flushing" stdin... */

        va_start(ptr, maxbuff);
        ret = vsscanf(buffer, fmt, ptr);
        va_end(ptr);
        return ret;
    }    
}

#define MAXBUFF 20
int main(void) {
   int x; 
   float z;
   int scanf_ret = my_scanf("%d %g", MAXBUFF, &x, &z);
   printf("\nTest:\n x == %d\n z == %g\n scanfret == %d", x, z, scanf_ret);
   getchar();   
   return 0;   
}

La fonction my_scanf() est le prototype

int my_scanf(const char* fmt, const int maxbuff, ...);

Il accepte une chaîne de format fmt qui se comporte de la même manière que toute autre scanf()-comme le fait.

Le 2ème paramètre est le nombre maximum de caractères qui seront effectivement acceptées à partir de l'entrée standard (clavier).

La valeur de retour est une int, qui est EOF si maxbuff n'a pas de sens, ou bien une entrée d'erreur qui s'est passé. Si une valeur non-négative est retourné, c'est le même qui serait retourné par les fonctions standard sscanf() ou vsscanf().

L'intérieur de la fonction, maxbuff est incrémenté de 1, parce que fgets() fait de la place pour un '\0' caractère.

Non-valeurs positives de maxbuff sont immédiatement rejetées.

fgets() va lire une chaîne de caractères est lu à partir de stdin (clavier) avec de la place pour au plus maxbuff caractères, y compris les '\n'.

Si l'utilisateur a entré une chaîne très longue, alors il sera bu tronquée, et une sorte de "chasse d'eau" mécanisme est nécessaire afin d'éliminer tous les caractères à la prochaine '\n' (ENTRER). Si pas, la prochaine clavier de la lecture, pourraient avoir des personnages plus âgés, ce n'est pas souhaitée à tous.

La condition de "rinçage" est que fgets() n'a pas atteint '\n' après la lecture de stdin.

C'est le cas si, et seulement si, buffer[maxbuff - 1] n'est pas égal à '\0' ni de '\n'.

(Vérifier!)

Enfin, une combinaison appropriée de stdarg.h macros et la fonction vsscanf() est utilisé pour traiter la liste variable de paramètres.

Comment sur

scanf("%.*[^\n]s", MAX_STR_LEN, sometext)