Rimozione del carattere newline finale dall'input di fgets ()

Sto cercando di ottenere alcuni dati dall'utente e inviarli a un'altra funzione in gcc. Il codice è qualcosa del genere.

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

Tuttavia, trovo che abbia un \ncarattere newline alla fine. Quindi, se Johnentro, finisce per inviare John\n. Come lo rimuovo \ne invio una stringa corretta.

Il modo leggermente brutto:

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

Il modo leggermente strano:

strtok(Name, "\n");

Si noti che la strtokfunzione non funziona come previsto se l'utente immette una stringa vuota (ovvero preme solo Invio). Lascia \nintatto il personaggio.

Ce ne sono anche altri, ovviamente.

Forse la soluzione più semplice utilizza una delle mie funzioni poco conosciute preferite strcspn():

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

Se vuoi che gestisca anche '\r'(ad esempio, se lo stream è binario):

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

La funzione conta il numero di caratteri fino a quando non colpisce a '\r'o a '\n'(in altre parole, trova il primo '\r'o '\n'). Se non colpisce nulla, si ferma al '\0'(restituendo la lunghezza della stringa).

Nota che funziona benissimo anche se non c'è una nuova riga, perché si strcspnferma a '\0'. In tal caso, l'intera riga viene semplicemente sostituita '\0'con '\0'.

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

Di seguito è riportato un approccio rapido per rimuovere un potenziale '\n'da una stringa salvata da fgets().
Usa strlen(), con 2 test.

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';
  }

Ora usa buffere lensecondo necessità.

Questo metodo ha il vantaggio collaterale di un lenvalore per il codice successivo. Può essere facilmente più veloce di strchr(Name, '\n'). Rif. YMMV, ma entrambi i metodi funzionano.

buffer, dall'originale fgets()non conterrà in "\n"alcune circostanze:
A) La riga era troppo lunga per buffercui solo la charprecedente '\n'viene salvata buffer. I caratteri non letti rimangono nel flusso.
B) L'ultima riga nel file non termina con a '\n'.

Se l'input contiene caratteri null incorporati '\0'da qualche parte, la lunghezza indicata da strlen()non includerà la '\n'posizione.

Alcune altre risposte ':

1. strtok(buffer, "\n");non riesce a rimuovere il '\n'quando bufferè "\n". Da questa risposta - modificato dopo questa risposta per avvertire di questa limitazione.

2. Quanto segue non riesce in rare occasioni in cui la prima charlettura fgets()è '\0'. Ciò accade quando l'input inizia con un incorporato '\0'. Quindi buffer[len -1]diventa buffer[SIZE_MAX]accesso alla memoria certamente al di fuori della gamma legittima di buffer. Qualcosa che un hacker può provare o trovare nella lettura folle dei file di testo UTF16. Questo era lo stato di una risposta quando questa risposta è stata scritta. Successivamente un non-OP lo ha modificato per includere codice come il controllo di questa risposta per "".

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

3. sprintf(buffer,"%s",buffer);è un comportamento indefinito: Rif . Inoltre, non salva spazi bianchi iniziali, separati o finali. Ora cancellato .

4. [Modifica a causa di una buona risposta successiva ] Non ci sono problemi con 1 liner buffer[strcspn(buffer, "\n")] = 0;oltre alle prestazioni rispetto strlen()all'approccio. Le prestazioni nel taglio di solito non sono un problema dato che il codice sta eseguendo I / O - un buco nero del tempo della CPU. Se il codice seguente richiede la lunghezza della stringa o è altamente sensibile alle prestazioni, utilizzare questo strlen()approccio. Altrimenti strcspn()è un'ottima alternativa.

Diretto per rimuovere '\ n' dall'output dei fgets se ogni riga ha '\ n'

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

Altrimenti:

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

Per il taglio singolo "\ n",

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

per il taglio multiplo '\ n',

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

Il mio modo per principianti ;-) Per favore fatemi sapere se è corretto. Sembra funzionare per tutti i miei casi:

#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;
}

I passaggi per rimuovere il carattere di nuova riga nel modo forse più ovvio:

1. Determina la lunghezza della stringa all'interno NAMEusando strlen(), header string.h. Si noti che strlen()non conta il termine \0.

size_t sl = strlen(NAME);

2. Verifica se la stringa inizia con o include solo un \0carattere (stringa vuota). In questo caso slsarebbe 0perché strlen()come ho detto sopra non conta \0e si ferma alla prima occorrenza di esso:

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

3. Controlla se l'ultimo carattere della stringa corretta è un carattere di nuova riga '\n'. In tal caso, sostituirlo \ncon a \0. Si noti che il conteggio degli indici inizia alle ore 0quindi dovremo fare NAME[sl - 1]:

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

Nota se hai solo premuto Invio alla fgets()richiesta di stringa (il contenuto della stringa era costituito solo da un carattere di nuova riga) la stringa in seguito NAMEsarà una stringa vuota da allora in poi.

4. Siamo in grado di combinare i passaggi 2. e 3. in una sola ifdichiarazione usando l'operatore logico &&:

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

5. Il codice finito:

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

Se preferisci una funzione per utilizzare questa tecnica gestendo fgetsle stringhe di output in generale senza dover riscrivere ogni volta, ecco 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';
    }
}

Nell'esempio fornito, sarebbe:

printf("Enter your Name: ");

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

Si noti che questo metodo non funziona se la stringa di input ha incorporato \0s in essa. Se così strlen()fosse, restituirebbe solo la quantità di caratteri fino al primo \0. Ma questo non è un approccio abbastanza comune, poiché le funzioni di lettura più stringhe di solito si fermano all'inizio \0e prendono la stringa fino a quel carattere nullo.

A parte la domanda da sola. Cercate di evitare doppie negazioni che compongono il codice unclearer: if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Puoi semplicemente farlo if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Tim Čas one liner è straordinario per le stringhe ottenute da una chiamata a fgets, perché sai che contengono una sola nuova riga alla fine.

Se ti trovi in ​​un contesto diverso e vuoi gestire stringhe che potrebbero contenere più di una nuova riga, potresti cercare strrspn. Non è POSIX, il che significa che non lo troverai su tutti gli Unices. Ne ho scritto uno per le mie esigenze.

/* 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;
}

Per coloro che cercano un equivalente chomp Perl in C, penso che sia così (chomp rimuove solo la nuova riga finale).

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

La funzione 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;
}

Se l'utilizzo getlineè un'opzione - Non trascurare i suoi problemi di sicurezza e se si desidera rinforzare i puntatori - è possibile evitare le funzioni di stringa poiché getlinerestituisce il numero di caratteri. Qualcosa come sotto

#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;
}

^{Nota : I [ problemi di sicurezza ] con getlinenon dovrebbero essere trascurati però.}

La funzione seguente è una parte della libreria di elaborazione delle stringhe che sto mantenendo su Github. Rimuove i caratteri indesiderati da una stringa, esattamente quello che vuoi

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 esempio potrebbe essere l'uso

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

Potresti voler controllare altre funzioni disponibili o persino contribuire al progetto :) https://github.com/fnoyanisi/zString

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

Dovresti provarlo. Questo codice sostanzialmente scorre la stringa fino a quando non trova "\ n". Quando viene trovato, "\ n" verrà sostituito dal carattere di terminazione null "\ 0"

Nota che stai confrontando i caratteri e non le stringhe in questa riga, quindi non è necessario usare strcmp ():

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

poiché utilizzerai virgolette singole e non doppie. Ecco un link su virgolette singole o doppie se vuoi saperne di più

Prova questo:

        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;
        }