Comment vérifier «\ n» à l'aide de scanf

Lorsque \ n est entré scanf se termine, s'il s'agit du premier caractère entré, par exemple Un utilisateur frappe immédiatement enter, 6 sera affiché par l'instruction printf.

Comportement non défini. Rien n'a été lu dans x [] non initialisé, donc strlen (x) est UB.

---

scanf ("% [^ \ n] s ", x); n'a pas de protection de largeur. Il n'a aucun contrôle de la valeur de retour. Détecter uniquement un '\ n' n'est pas anodin.

Utilisez fgets().

int main(){
  // char x[6];
  char x[7];  // add at least 1 (useful for the \n code may read)
  // scanf("%[^\n]s", x);
  if (fgets(x, sizeof x, stdin)) {
    x[strcspn(x, "\n")] = '\0'; // lop off potential trailing \n
    // printf("%i\n", strlen(x));
    printf("%zu\n", strlen(x));  // use matching specifier
    return 0;
  }
}

char *removetrailinglineends(char *str)
{
    size_t len = strlen(str);
    char *end = str + !len ? str : str + len - 1;

    while(end > str)
    {
        if(*end == '\n' || *end == '\r') *end = 0;
        end--;
    }
}

Vous pouvez utiliser getchar () pour vérifier chaque caractère d'entrée individuel et arrêter de prendre des entrées lorsque la taille d'entrée est de 6 ou que l'utilisateur saisit \ n .

Modifier: j'ai mis à jour mon code conformément à la suggestion de @ chux. Vous devez augmenter la taille du tableau à 7 afin que le dernier caractère puisse être le terminateur nul lorsque l'entrée dépasse 6 caractères. J'ai également utilisé une variable int c pour stocker les valeurs de retour de getchar au lieu de les stocker directement dans x [i] afin qu'il puisse identifier EOF .

#include<stdio.h>
#include<string.h>

int main(){
    char x[7];
    int c;
    size_t i = 0;
    while (i < 6 && (c=getchar()) != EOF) {
       x[i] = c;
       if (x[i] == '\n') {
           break;
       }
       ++i; 
    }
    x[i] = '\0'; // null-terminate string
    printf("%s\n", x);
    printf("%lu\n", strlen(x));
    return 0;
}

Outre la question principale, le code présente plusieurs problèmes:

char x[6] = ""; // fill NUL chars
int n_read = scanf ("%5[^\n]", x); // ok
if (n_read < 0) error...
else if (n_read == 0) newline or EOF...
else /*1*/  x is ready...

Résoudre les problèmes un par un:

char x[6] = ""; // fill NUL chars
scanf ("%5[^\n]", x); // better

Cela se lira jusqu'à la nouvelle ligne et s'arrêtera, mais peut encore déborder de la mémoire tampon:

scanf ("%5[^\n]", x); // better

Cela évitera le débordement de tampon, en limitant la lecture à 5 caractères. Malheureusement, si l'entrée est longue, il n'y a aucune garantie qu'un terminateur nul sera écrit à la fin. De plus, si scanf échoue (comme dans votre cas), alors x ne sera pas initialisé:

scanf("%[^\n]", x); // still not good

Cela fonctionnera mal si après la lecture de 3 caractères, par exemple, il y aura un IO problème. Pour lutter contre ce genre de problèmes, vérifiez le code de retour:

int main(){
    char x[6];
    // 1. an attack vector: lines with more than 6 characters will exceed buffer size
    // 2. The s will never be matched, 
    //      since %[^\n] consumes everything until EOF or \n
    // the following char can't be 's'      
    scanf("%[^\n]s", x);
    // if scanf fails, then x can be uninitialized:
    printf("%i\n", strlen(x));
    return 0;
}

Notez qu'au lieu d'initialiser x = "" , il est probablement préférable de set x [5] = '\ 0' après scanf. J'ai choisi l'option d'initialisation à la place, car il était plus facile de présenter la réponse progressivement de cette façon.