Usuwanie końcowego znaku nowej linii z wprowadzania fgets ()

Próbuję pobrać dane od użytkownika i wysłać je do innej funkcji w gcc. Kod jest mniej więcej taki.

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

Uważam jednak, że ma on \nna końcu znak nowej linii . Więc jeśli Johnwejdę, wyśle ​​to John\n. Jak to usunąć \ni wysłać odpowiedni ciąg.

Nieco brzydki sposób:

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

Nieco dziwny sposób:

strtok(Name, "\n");

Zauważ, że strtokfunkcja nie działa zgodnie z oczekiwaniami, jeśli użytkownik wprowadzi pusty ciąg znaków (tzn. Naciśnie tylko Enter). Pozostawia \npostać nietkniętą.

Oczywiście są też inni.

Być może najprostsze rozwiązanie wykorzystuje jedną z moich ulubionych mało znanych funkcji strcspn():

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

Jeśli chcesz, aby również obsługiwał '\r'(powiedzmy, jeśli strumień jest binarny):

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

Funkcja zlicza liczbę znaków, aż trafi na a '\r'lub a '\n'(innymi słowy, znajdzie pierwszy '\r'lub '\n'). Jeśli niczego nie trafi, zatrzymuje się na '\0'(zwracając długość łańcucha).

Zauważ, że działa to dobrze, nawet jeśli nie ma nowej linii, ponieważ strcspnkończy się na '\0'. W takim przypadku cała linia po prostu zastępuje '\0'się '\0'.

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

Poniżej znajduje się szybkie podejście do usunięcia potencjału '\n'z ciągu zapisanego przez fgets().
Używa strlen(), z 2 testami.

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

Teraz użyj bufferilen w razie potrzeby.

Ta metoda ma dodatkową zaletę lenwartości dla kolejnego kodu. Może być łatwo szybszy niż strchr(Name, '\n'). Ref YMMV, ale obie metody pracy.

buffer, z oryginału fgets()nie będzie zawierał w "\n"pewnych okolicznościach:
A) Linia była zbyt długa, bufferdlatego zapisano ją tylko charprzed nią . Nieprzeczytane znaki pozostają w strumieniu. B) Ostatni wiersz w pliku nie kończył się na'\n'buffer
'\n' .

Jeśli dane wejściowe mają '\0'gdzieś osadzone znaki zerowe , podawana przez strlen()nie długość nie uwzględni '\n'lokalizacji.

Niektóre inne problemy z odpowiedziami:

1. strtok(buffer, "\n");nie usuwa '\n'kiedy bufferjest "\n". Z tej odpowiedzi - poprawionej po tej odpowiedzi w celu ostrzeżenia o tym ograniczeniu.

2. Następujące przypadki zawodzą w rzadkich przypadkach, gdy pierwszy charodczyt fgets()jest '\0'. Dzieje się tak, gdy dane wejściowe zaczynają się od osadzenia '\0'. Wtedy buffer[len -1]staje się buffer[SIZE_MAX]dostęp do pamięci z pewnością poza uzasadnionym zakresie buffer. Coś, co haker może spróbować znaleźć w niemądrym czytaniu plików tekstowych UTF16. Taki był stan odpowiedzi, kiedy ta odpowiedź została napisana. Później edytor nieobsługujący OP zmodyfikował go, aby uwzględnić kod podobny do sprawdzania tej odpowiedzi "".

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

3. sprintf(buffer,"%s",buffer);jest niezdefiniowane zachowanie: Ref . Ponadto nie zapisuje żadnych początkowych, oddzielających ani końcowych białych znaków. Teraz usunięte .

4. [Edytuj ze względu na dobrą późniejszą odpowiedź ] Nie ma żadnych problemów z 1 wkładką buffer[strcspn(buffer, "\n")] = 0;poza wydajnością w porównaniu do strlen()podejścia. Wydajność przycinania zwykle nie stanowi problemu, ponieważ kod wykonuje operacje we / wy - czarna dziura czasu procesora. Jeśli następujący kod wymaga długości łańcucha lub jest wysoce świadomy wydajności, użyj tego strlen()podejścia. W przeciwnym razie strcspn()jest to dobra alternatywa.

Bezpośrednio, aby usunąć „\ n” z wyjścia fgets, jeśli każda linia ma „\ n”

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

Inaczej:

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

W przypadku przycinania pojedynczego „\ n”,

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

do wielokrotnego przycinania „\ n”,

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

Mój nowy sposób ;-) Daj mi znać, jeśli to prawda. Wygląda na to, że działa we wszystkich moich przypadkach:

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

Kroki, aby usunąć znak nowej linii w możliwie najbardziej oczywisty sposób:

1. Określ długość łańcucha wewnątrz NAMEza pomocą strlen()nagłówka string.h. Zauważ, że strlen()nie liczy się zakończenie \0.

size_t sl = strlen(NAME);

2. Sprawdź, czy ciąg zaczyna się od, czy zawiera tylko jeden \0znak (pusty ciąg). W takim przypadku slbyłoby, 0ponieważ, strlen()jak powiedziałem powyżej, nie liczy się \0i zatrzymuje przy pierwszym wystąpieniu:

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

3. Sprawdź, czy ostatni znak właściwego ciągu jest znakiem nowego wiersza '\n'. W takim przypadku zamień \nna \0. Pamiętaj, że liczenie indeksów zaczyna się od, 0więc będziemy musieli zrobić NAME[sl - 1]:

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

Zauważ, że jeśli naciśniesz Enter tylko na fgets()żądanie łańcucha (treść łańcucha składała się tylko ze znaku nowej linii), łańcuch NAMEbędzie później pusty.

4. Możemy połączyć krok 2. i 3. razem w jednym ifzestawieniu, używając operatora logicznego &&:

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

5. Gotowy kod:

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

Jeśli wolisz funkcję używającą tej techniki, obsługującą fgetsciągi wyjściowe w ogóle bez ponownego wpisywania za każdym razem, oto 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';
    }
}

W podanym przykładzie byłoby to:

printf("Enter your Name: ");

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

Zauważ, że ta metoda nie działa, jeśli łańcuch wejściowy ma \0w niej osadzone s. W takim przypadku strlen()zwracałaby tylko liczbę znaków do pierwszego \0. Ale nie jest to dość powszechne podejście, ponieważ większość funkcji czytania ciągów zwykle zatrzymuje się na początku\0 i pobiera ciąg znaków aż do znaku o wartości zerowej.

Oprócz samego pytania. Staraj się unikać podwójnych negacji, które czynią swój kod unclearer: if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Możesz po prostu zrobić if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Jeden linijka Tim Čas jest niesamowity dla ciągów uzyskanych przez wezwanie do fgets, ponieważ wiesz, że zawierają jedną nową linię na końcu.

Jeśli jesteś w innym kontekście i chcesz obsługiwać ciągi znaków, które mogą zawierać więcej niż jeden znak nowej linii, być może szukasz strrspn. To nie jest POSIX, co oznacza, że ​​nie znajdziesz go na wszystkich Uniksach. Napisałem jeden na własne potrzeby.

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

Dla tych, którzy szukają Perl chomp równoważnych w C, myślę, że to jest to (chomp usuwa tylko końcowy znak nowej linii).

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

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

Jeśli użycie getlinejest opcją - Nie zaniedbując jej problemów związanych z bezpieczeństwem i jeśli chcesz nawiasować wskaźniki - możesz uniknąć funkcji łańcuchowych, ponieważ getlinezwraca liczbę znaków. Coś jak poniżej

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

^{Uwaga : W [ kwestie bezpieczeństwa ] z getlinenie należy lekceważyć, choć.}

Poniższa funkcja jest częścią biblioteki przetwarzania ciągów, którą utrzymuję w Github. Usuwa niechciane znaki z łańcucha dokładnie tego, czego chcesz

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

Przykładem użycia może być

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

Możesz sprawdzić inne dostępne funkcje, a nawet przyczynić się do projektu :) https://github.com/fnoyanisi/zString

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

Powinieneś spróbować. Ten kod zasadniczo przechodzi przez ciąg znaków, aż znajdzie „\ n”. Po znalezieniu „\ n” zostanie zastąpione przez terminator znaku zerowego „\ 0”

Zauważ, że porównujesz znaki, a nie łańcuchy w tym wierszu, więc nie musisz używać strcmp ():

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

ponieważ będziesz używać pojedynczych cudzysłowów, a nie podwójnych. Oto link o pojedynczych lub podwójnych cudzysłowach, jeśli chcesz dowiedzieć się więcej

Spróbuj tego:

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