Suppression du caractère de fin de ligne de l'entrée fgets ()

J'essaie d'obtenir des données de l'utilisateur et de les envoyer à une autre fonction dans gcc. Le code est quelque chose comme ça.

printf("Enter your Name: ");
if (!(fgets(Name, sizeof Name, stdin) != NULL)) {
    fprintf(stderr, "Error reading Name.\n");
    exit(1);
}

Cependant, je trouve qu'il a un \ncaractère de nouvelle ligne à la fin. Donc, si j'entre, Johnil finit par envoyer John\n. Comment puis-je supprimer cela \net envoyer une chaîne appropriée.

La manière légèrement laide:

char *pos;
if ((pos=strchr(Name, '\n')) != NULL)
    *pos = '\0';
else
    /* input too long for buffer, flag error */

La manière un peu étrange:

strtok(Name, "\n");

Notez que la strtokfonction ne fonctionne pas comme prévu si l'utilisateur entre une chaîne vide (c'est-à-dire qu'il appuie uniquement sur Entrée). Il laisse le \npersonnage intact.

Il y en a bien sûr d'autres également.

Peut-être que la solution la plus simple utilise l'une de mes fonctions préférées les moins connues strcspn():

buffer[strcspn(buffer, "\n")] = 0;

Si vous souhaitez qu'il gère également '\r'(par exemple, si le flux est binaire):

buffer[strcspn(buffer, "\r\n")] = 0; // works for LF, CR, CRLF, LFCR, ...

La fonction compte le nombre de caractères jusqu'à ce qu'elle atteigne a '\r'ou a '\n'(en d'autres termes, elle trouve le premier '\r'ou '\n'). S'il ne touche rien, il s'arrête à '\0'(renvoyant la longueur de la chaîne).

Notez que cela fonctionne bien même s'il n'y a pas de nouvelle ligne, car strcspns'arrête à a '\0'. Dans ce cas, la ligne entière est simplement remplacée '\0'par '\0'.

size_t ln = strlen(name) - 1;
if (*name && name[ln] == '\n') 
    name[ln] = '\0';

Vous trouverez ci-dessous une approche rapide pour supprimer un potentiel '\n'd'une chaîne enregistrée par fgets().
Il utilise strlen(), avec 2 tests.

char buffer[100];
if (fgets(buffer, sizeof buffer, stdin) != NULL) {

  size_t len = strlen(buffer);
  if (len > 0 && buffer[len-1] == '\n') {
    buffer[--len] = '\0';
  }

Maintenant, utilisez bufferet lenau besoin.

Cette méthode a l'avantage secondaire d'une lenvaleur pour le code suivant. Cela peut être facilement plus rapide que strchr(Name, '\n'). Réf YMMV, mais les deux méthodes fonctionnent.

buffer, à partir de l'original fgets()ne contiendra pas dans "\n"certaines circonstances:
A) La ligne était trop longue pour bufferque seulement le charprécédent '\n'soit enregistré dans buffer. Les caractères non lus restent dans le flux.
B) La dernière ligne du fichier ne s'est pas terminée par un '\n'.

Si l'entrée contient des caractères nuls '\0'quelque part, la longueur signalée par strlen()n'inclura pas l' '\n'emplacement.

Quelques autres questions de réponses:

1. strtok(buffer, "\n");ne parvient pas à supprimer le '\n'quand bufferest "\n". De cette réponse - modifié après cette réponse pour avertir de cette limitation.

2. Ce qui suit échoue en de rares occasions lorsque la première charlecture fgets()est '\0'. Cela se produit lorsque l'entrée commence par un imbriqué '\0'. Devient buffer[len -1]alors buffer[SIZE_MAX]accéder à la mémoire certainement en dehors de la plage légitime de buffer. Quelque chose qu'un pirate pourrait essayer ou trouver en lisant bêtement des fichiers texte UTF16. C'était l'état d'une réponse lorsque cette réponse a été écrite. Plus tard, un non-OP l'a édité pour inclure du code comme la vérification de cette réponse "".

   size_t len = strlen(buffer);
   if (buffer[len - 1] == '\n') {  // FAILS when len == 0
     buffer[len -1] = '\0';
   }

3. sprintf(buffer,"%s",buffer);est un comportement indéfini: Réf . En outre, il n'enregistre aucun espace de début, de séparation ou de fin. Maintenant supprimé .

4. [Modifier en raison d'une bonne réponse ultérieure ] Il n'y a aucun problème avec la doublure buffer[strcspn(buffer, "\n")] = 0;autre que les performances par rapport à l' strlen()approche. Les performances de découpage ne sont généralement pas un problème étant donné que le code fait des E / S - un trou noir du temps CPU. Si le code suivant nécessite la longueur de la chaîne ou est très sensible aux performances, utilisez cette strlen()approche. Sinon, strcspn()c'est une bonne alternative.

Direct pour supprimer le '\ n' de la sortie fgets si chaque ligne a '\ n'

line[strlen(line) - 1] = '\0';

Autrement:

void remove_newline_ch(char *line)
{
    int new_line = strlen(line) -1;
    if (line[new_line] == '\n')
        line[new_line] = '\0';
}

Pour un découpage '\ n' unique,

void remove_new_line(char* string)
{
    size_t length = strlen(string);
    if((length > 0) && (string[length-1] == '\n'))
    {
        string[length-1] ='\0';
    }
}

pour un découpage "\ n" multiple,

void remove_multi_new_line(char* string)
{
  size_t length = strlen(string);
  while((length>0) && (string[length-1] == '\n'))
  {
      --length;
      string[length] ='\0';
  }
}

My Newbie way ;-) Veuillez me faire savoir si c'est correct. Il semble fonctionner pour tous mes cas:

#define IPT_SIZE 5

int findNULL(char* arr)
{
    for (int i = 0; i < strlen(arr); i++)
    {
        if (*(arr+i) == '\n')
        {
            return i;
        }
    }
    return 0;
}

int main()
{
    char *input = malloc(IPT_SIZE + 1 * sizeof(char)), buff;
    int counter = 0;

    //prompt user for the input:
    printf("input string no longer than %i characters: ", IPT_SIZE);
    do
    {
        fgets(input, 1000, stdin);
        *(input + findNULL(input)) = '\0';
        if (strlen(input) > IPT_SIZE)
        {
            printf("error! the given string is too large. try again...\n");
            counter++;
        }
        //if the counter exceeds 3, exit the program (custom function):
        errorMsgExit(counter, 3); 
    }
    while (strlen(input) > IPT_SIZE);

//rest of the program follows

free(input)
return 0;
}

Les étapes pour supprimer le caractère de nouvelle ligne de la manière peut-être la plus évidente:

1. Déterminez la longueur de la chaîne à l'intérieur NAMEen utilisant strlen(), header string.h. Notez que strlen()cela ne compte pas la terminaison \0.

size_t sl = strlen(NAME);

2. Vérifiez si la chaîne commence par ou ne comprend qu'un seul \0caractère (chaîne vide). Dans ce cas sl, 0car strlen()comme je l'ai dit ci-dessus ne compte pas le \0et s'arrête à sa première occurrence:

if(sl == 0)
{
   // Skip the newline replacement process.
}

3. Vérifiez si le dernier caractère de la chaîne appropriée est un caractère de nouvelle ligne '\n'. Si tel est le cas, remplacez-le \npar un \0. Notez que le nombre d'index commence à 0donc nous devrons faire NAME[sl - 1]:

if(NAME[sl - 1] == '\n')
{
   NAME[sl - 1] = '\0';
}

Notez que si vous avez uniquement appuyé sur Entrée à la fgets()demande de chaîne (le contenu de la chaîne était uniquement composé d'un caractère de nouvelle ligne), la chaîne en NAMEsera une chaîne vide par la suite.

4. Nous pouvons combiner les étapes 2. et 3. ensemble en une seule ifdéclaration en utilisant l'opérateur logique &&:

if(sl > 0 && NAME[sl - 1] == '\n')
{
   NAME[sl - 1] = '\0';
}

5. Le code fini:

size_t sl = strlen(NAME);
if(sl > 0 && NAME[sl - 1] == '\n')
{
   NAME[sl - 1] = '\0';
}

Si vous aimez plutôt une fonction pour utiliser cette technique en gérant fgetsles chaînes de sortie en général sans retaper à chaque fois, voici fgets_newline_kill:

void fgets_newline_kill(char a[])
{
    size_t sl = strlen(a);

    if(sl > 0 && a[sl - 1] == '\n')
    {
       a[sl - 1] = '\0';
    }
}

Dans votre exemple fourni, ce serait:

printf("Enter your Name: ");

if (fgets(Name, sizeof Name, stdin) == NULL) {
    fprintf(stderr, "Error reading Name.\n");
    exit(1);
}
else {
    fgets_newline_kill(NAME);
}

Notez que cette méthode ne fonctionne pas si la chaîne d'entrée contient des \0s incorporés . Si tel était le cas strlen(), le nombre de caractères ne serait renvoyé que jusqu'au premier \0. Mais ce n'est pas une approche assez courante, car la plupart des fonctions de lecture de chaîne s'arrêtent généralement au premier \0et prennent la chaîne jusqu'à ce caractère nul.

Mis à part la question seule. Essayez d'éviter la double négations qui font votre code unclearer: if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Vous pouvez simplement le faire if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Tim Čas one liner est étonnant pour les cordes obtenues par un appel aux fgets, car vous savez qu'ils contiennent une seule nouvelle ligne à la fin.

Si vous êtes dans un contexte différent et que vous souhaitez gérer des chaînes pouvant contenir plusieurs sauts de ligne, vous recherchez peut-être strrspn. Ce n'est pas POSIX, ce qui signifie que vous ne le trouverez pas sur tous les Unices. J'en ai écrit un pour mes propres besoins.

/* Returns the length of the segment leading to the last 
   characters of s in accept. */
size_t strrspn (const char *s, const char *accept)
{
  const char *ch;
  size_t len = strlen(s);

more: 
  if (len > 0) {
    for (ch = accept ; *ch != 0 ; ch++) {
      if (s[len - 1] == *ch) {
        len--;
        goto more;
      }
    }
  }
  return len;
}

Pour ceux qui recherchent un équivalent de chomp Perl en C, je pense que c'est ça (chomp ne supprime que la nouvelle ligne de fin).

line[strrspn(string, "\r\n")] = 0;

La fonction strrcspn:

/* Returns the length of the segment leading to the last 
   character of reject in s. */
size_t strrcspn (const char *s, const char *reject)
{
  const char *ch;
  size_t len = strlen(s);
  size_t origlen = len;

  while (len > 0) {
    for (ch = reject ; *ch != 0 ; ch++) {
      if (s[len - 1] == *ch) {
        return len;
      }
    }
    len--;
  }
  return origlen;
}

Si l'utilisation getlineest une option - sans négliger ses problèmes de sécurité et si vous souhaitez renforcer les pointeurs - vous pouvez éviter les fonctions de chaîne car la getlinerenvoie le nombre de caractères. Quelque chose comme ci-dessous

#include<stdio.h>
#include<stdlib.h>
int main(){
char *fname,*lname;
size_t size=32,nchar; // Max size of strings and number of characters read
fname=malloc(size*sizeof *fname);
lname=malloc(size*sizeof *lname);
if(NULL == fname || NULL == lname){
 printf("Error in memory allocation.");
 exit(1);
}
printf("Enter first name ");
nchar=getline(&fname,&size,stdin);
if(nchar == -1){ // getline return -1 on failure to read a line.
 printf("Line couldn't be read.."); 
 // This if block could be repeated for next getline too
 exit(1);
}
printf("Number of characters read :%zu\n",nchar);
fname[nchar-1]='\0';
printf("Enter last name ");
nchar=getline(&lname,&size,stdin);
printf("Number of characters read :%zu\n",nchar);
lname[nchar-1]='\0';
printf("Name entered %s %s\n",fname,lname);
return 0;
}

^{Remarque : Les [ problèmes de sécurité ] avec getlinene doivent pas être négligés cependant.}

La fonction ci-dessous fait partie de la bibliothèque de traitement de chaînes que je gère sur Github. Il supprime et les caractères indésirables d'une chaîne, exactement ce que vous voulez

int zstring_search_chr(const char *token,char s){
    if (!token || s=='\0')
        return 0;

    for (;*token; token++)
        if (*token == s)
            return 1;

    return 0;
}

char *zstring_remove_chr(char *str,const char *bad) {
    char *src = str , *dst = str;
    while(*src)
        if(zstring_search_chr(bad,*src))
            src++;
        else
            *dst++ = *src++;  /* assign first, then incement */

    *dst='\0';
        return str;
}

Un exemple d'utilisation pourrait être

Example Usage
      char s[]="this is a trial string to test the function.";
      char const *d=" .";
      printf("%s\n",zstring_remove_chr(s,d));

  Example Output
      thisisatrialstringtotestthefunction

Vous voudrez peut-être vérifier d'autres fonctions disponibles, ou même contribuer au projet :) https://github.com/fnoyanisi/zString

 for(int i = 0; i < strlen(Name); i++ )
{
    if(Name[i] == '\n') Name[i] = '\0';
}

Tu devrais essayer. Ce code parcourt en boucle la chaîne jusqu'à ce qu'il trouve le '\ n'. Lorsqu'il est trouvé, le '\ n' sera remplacé par le terminateur de caractère nul '\ 0'

Notez que vous comparez des caractères et non des chaînes dans cette ligne, il n'est donc pas nécessaire d'utiliser strcmp ():

if(Name[i] == '\n') Name[i] = '\0';

puisque vous utiliserez des guillemets simples et non des guillemets doubles. Voici un lien sur les guillemets simples vs doubles si vous voulez en savoir plus

Essaye celui-là:

        int remove_cr_lf(char *str)
        {
          int len =0;


          len = strlen(str);

          for(int i=0;i<5;i++)
          {
            if (len>0)
            if (str[len-1] == '\n')
            {
              str[len-1] = 0;
              len--;
            }

            if (len>0)
            if (str[len-1] == '\r')
            {
              str[len-1] = 0;
              len--;
            }
          }

          return 0;
        }