Entfernen des nachgestellten Zeilenumbruchs aus der Eingabe von fgets ()

Ich versuche, einige Daten vom Benutzer abzurufen und an eine andere Funktion in gcc zu senden. Der Code ist ungefähr so.

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

Ich finde jedoch, dass es \nam Ende einen Zeilenumbruch hat . Wenn ich also eintrete, wird Johnes gesendet John\n. Wie entferne ich das \nund sende eine richtige Zeichenfolge.

Der etwas hässliche Weg:

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

Der etwas seltsame Weg:

strtok(Name, "\n");

Beachten Sie, dass die strtokFunktion nicht wie erwartet funktioniert, wenn der Benutzer eine leere Zeichenfolge eingibt (dh nur die Eingabetaste drückt). Es lässt den \nCharakter intakt.

Natürlich gibt es auch andere.

Vielleicht verwendet die einfachste Lösung eine meiner wenig bekannten Lieblingsfunktionen strcspn():

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

Wenn Sie möchten, dass es auch funktioniert '\r'(z. B. wenn der Stream binär ist):

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

Die Funktion zählt die Anzahl der Zeichen, bis sie a '\r'oder a trifft '\n'(mit anderen Worten, sie findet das erste '\r'oder '\n'). Wenn es nichts trifft, stoppt es bei '\0'(Rückgabe der Länge der Zeichenfolge).

Beachten Sie, dass dies auch dann gut funktioniert, wenn keine neue Zeile vorhanden ist, da strcspnbei a angehalten wird '\0'. In diesem Fall wird die gesamte Linie einfach zu ersetzen '\0'mit '\0'.

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

Im Folgenden finden Sie einen schnellen Ansatz zum Entfernen eines Potenzials '\n'aus einer von gespeicherten Zeichenfolge fgets().
Es verwendet strlen()mit 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';
  }

Verwenden Sie jetzt bufferund lennach Bedarf.

Diese Methode hat den Nebeneffekt eines lenWerts für nachfolgenden Code. Es kann leicht schneller sein als strchr(Name, '\n'). Ref YMMV, aber beide Methoden funktionieren.

buffer, aus dem Original fgets()wird "\n"unter Umständen nicht enthalten :
A) Die Zeile war zu lang, bufferso dass nur charvor dem '\n'gespeichert wird buffer. Die ungelesenen Zeichen bleiben im Stream.
B) Die letzte Zeile in der Datei endete nicht mit a'\n' .

Wenn in die Eingabe '\0'irgendwo Nullzeichen eingebettet sind , enthält die von gemeldete Länge strlen()nicht die '\n'Position.

Einige andere Antworten:

1. strtok(buffer, "\n");zu entfernen , schlägt die , '\n'wenn bufferist "\n". Aus dieser Antwort - nach dieser Antwort geändert, um vor dieser Einschränkung zu warnen.

2. Das Folgende schlägt in seltenen Fällen fehl, wenn das erste charLesen von fgets()ist '\0'. Dies geschieht, wenn die Eingabe mit einem Embedded beginnt '\0'. Dann buffer[len -1]wird der buffer[SIZE_MAX]Zugriff auf Speicher sicherlich außerhalb des legitimen Bereichs von buffer. Etwas, das ein Hacker versuchen oder finden könnte, wenn er törichterweise UTF16-Textdateien liest. Dies war der Stand einer Antwort, als diese Antwort geschrieben wurde. Später wurde es von einem Nicht-OP so bearbeitet, dass es Code wie die Antwort dieser Antwort enthält "".

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

3. sprintf(buffer,"%s",buffer);ist undefiniertes Verhalten: Ref . Außerdem werden keine führenden, trennenden oder nachfolgenden Leerzeichen gespeichert. Jetzt gelöscht .

4. [Bearbeiten aufgrund einer guten späteren Antwort ] Es gibt keine Probleme mit dem 1-Liner buffer[strcspn(buffer, "\n")] = 0;außer der Leistung im Vergleich zum strlen()Ansatz. Die Leistung beim Trimmen ist normalerweise kein Problem, da der Code E / A ausführt - ein schwarzes Loch der CPU-Zeit. Wenn der folgende Code die Länge der Zeichenfolge benötigt oder sehr leistungsbewusst ist, verwenden Sie diesen strlen()Ansatz. Sonst strcspn()ist das eine gute Alternative.

Direkt, um das '\ n' aus der fgets-Ausgabe zu entfernen, wenn jede Zeile '\ n' hat.

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

Andernfalls:

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

Für einzelnes '\ n' Trimmen,

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

für mehrfaches '\ n' Trimmen,

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

Mein Neuling Weg ;-) Bitte lassen Sie mich wissen, ob das richtig ist. Es scheint für alle meine Fälle zu funktionieren:

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

Die Schritte zum Entfernen des Zeilenumbruchs auf die vielleicht offensichtlichste Weise:

1. Bestimmen Sie die Länge der Zeichenfolge im Inneren NAMEmithilfe der strlen()Kopfzeile string.h. Beachten Sie, dass strlen()das Beenden nicht berücksichtigt wird \0.

size_t sl = strlen(NAME);

2. Überprüfen Sie, ob die Zeichenfolge mit einem \0Zeichen beginnt oder nur ein Zeichen enthält (leere Zeichenfolge). In diesem Fall slwäre, 0da, strlen()wie ich oben sagte, das nicht zählt \0und beim ersten Auftreten davon stoppt:

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

3. Überprüfen Sie, ob das letzte Zeichen der richtigen Zeichenfolge ein Zeilenumbruchzeichen ist '\n'. Wenn dies der Fall ist, ersetzen Sie \ndurch a \0. Beachten Sie, dass die Indexzählungen bei beginnen, 0sodass wir Folgendes tun müssen NAME[sl - 1]:

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

Hinweis: Wenn Sie bei der fgets()Zeichenfolgenanforderung nur die Eingabetaste gedrückt haben (der Zeichenfolgeninhalt bestand nur aus einem Zeilenumbruchzeichen), ist die NAMEZeichenfolge danach eine leere Zeichenfolge.

4. Wir können Schritt 2. und 3. in nur einer ifAnweisung zusammenfassen, indem wir den Logikoperator verwenden &&:

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

5. Der fertige Code:

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

Wenn Sie eine Funktion zur Verwendung dieser Technik fgetsbevorzugen , indem Sie Ausgabezeichenfolgen im Allgemeinen verarbeiten, ohne sie jedes Mal neu einzugeben, finden Sie hier 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';
    }
}

In Ihrem Beispiel wäre dies:

printf("Enter your Name: ");

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

Beachten Sie, dass diese Methode nicht funktioniert, wenn in die Eingabezeichenfolge \0s eingebettet ist. Wenn dies der Fall strlen()wäre, würde nur die Anzahl der Zeichen bis zum ersten zurückgegeben \0. Dies ist jedoch kein gängiger Ansatz, da die meisten Funktionen zum Lesen von Zeichenfolgen normalerweise beim ersten anhalten \0und die Zeichenfolge bis zu diesem Nullzeichen verwenden.

Abgesehen von der Frage für sich. Vermeiden Sie doppelte Negationen, die Ihren Code unklar machen : if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Sie können einfach tun if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Tim Čas ein Liner ist erstaunlich für Strings, die durch einen Aufruf von fgets erhalten werden, weil Sie wissen, dass sie am Ende eine einzelne Newline enthalten.

Wenn Sie sich in einem anderen Kontext befinden und Zeichenfolgen verarbeiten möchten, die möglicherweise mehr als eine neue Zeile enthalten, suchen Sie möglicherweise nach strrspn. Es ist nicht POSIX, was bedeutet, dass Sie es nicht auf allen Unices finden. Ich habe eine für meine eigenen Bedürfnisse geschrieben.

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

Für diejenigen, die nach einem Perl-Chomp-Äquivalent in C suchen, ist dies meiner Meinung nach das Richtige (Chomp entfernt nur die nachfolgende Newline).

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

Die strrcspn-Funktion:

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

Wenn die Verwendung getlineeine Option ist - ohne die Sicherheitsprobleme zu vernachlässigen und Zeiger zu klammern -, können Sie Zeichenfolgenfunktionen vermeiden, da getlinedie Anzahl der Zeichen zurückgegeben wird. So etwas wie unten

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

^{Hinweis : Die [ Sicherheitsprobleme ] mit getlinesollten jedoch nicht vernachlässigt werden.}

Die folgende Funktion ist Teil der String-Verarbeitungsbibliothek, die ich auf Github verwalte. Es entfernt und unerwünschte Zeichen aus einer Zeichenfolge, genau das, was Sie wollen

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

Ein Beispiel für eine Verwendung könnte sein

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

Vielleicht möchten Sie andere verfügbare Funktionen überprüfen oder sogar zum Projekt beitragen :) https://github.com/fnoyanisi/zString

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

Sie sollten es versuchen. Dieser Code durchläuft im Grunde die Zeichenfolge, bis er das '\ n' findet. Wenn es gefunden wird, wird das '\ n' durch den Nullzeichen-Terminator '\ 0' ersetzt.

Beachten Sie, dass Sie Zeichen und keine Zeichenfolgen in dieser Zeile vergleichen. Dann müssen Sie strcmp () nicht verwenden:

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

da Sie einfache Anführungszeichen und keine doppelten Anführungszeichen verwenden. Hier ist ein Link zu einfachen oder doppelten Anführungszeichen, wenn Sie mehr wissen möchten

Probier diese:

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