Entfernen des nachgestellten Newline-Zeichens aus der fgets()-Eingabe

Question 1

Ich versuche, einige Daten vom Benutzer zu erhalten und sie 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 einen Zeilenumbruch hat \n Charakter am Ende. Also wenn ich eintrete John es endet mit dem Senden John\n. Wie entferne ich das \n und sende einen richtigen String.

Question 2

Die vielleicht einfachste Lösung verwendet eine meiner wenig bekannten Lieblingsfunktionen, strcspn():

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

Wenn Sie es auch handhaben möchten '\r' (sagen wir, 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 auf a trifft '\r' oder ein '\n' (mit anderen Worten, es findet die erste '\r' oder '\n'). Wenn es nichts trifft, stoppt es am '\0' (Rückgabe der Länge der Zeichenfolge).

Beachten Sie, dass dies auch ohne Zeilenumbruch funktioniert, weil strcspn stoppt bei a '\0'. In diesem Fall wird einfach die gesamte Leitung ausgetauscht '\0' mit '\0'.

Question 3

Der elegante Weg:

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

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");

Notiere dass der strtok Die Funktion funktioniert nicht wie erwartet, wenn der Benutzer eine leere Zeichenfolge eingibt (dh nur die Eingabetaste drückt). Es verlässt die \n Charakter intakt.

Es gibt natürlich auch andere.

Question 4

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

Question 5

Unten ist ein schneller Ansatz, um ein Potenzial zu entfernen '\n' aus einer Zeichenfolge, die von gespeichert wurde 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';
  }

Jetzt benutzen buffer und len wie benötigt.

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

buffervom Original fgets() enthält nicht in "\n" unter Umständen:
A) Die Schlange war zu lang für buffer also nur char vor dem '\n' eingespart wird buffer. Die ungelesenen Zeichen verbleiben im Stream.
B) Die letzte Zeile in der Datei endete nicht mit a '\n'.

Wenn die Eingabe Nullzeichen eingebettet hat '\0' irgendwo drin steht die länge von gemeldet strlen() wird die nicht enthalten '\n' Lage.

Einige andere Antworten Probleme:

strtok(buffer, "\n"); kann die nicht entfernen '\n' Wenn buffer ist "\n". Aus dieser Antwort – nach dieser Antwort geändert, um vor dieser Einschränkung zu warnen.
Das Folgende schlägt in seltenen Fällen beim ersten fehl char gelesen von fgets() ist '\0'. Dies geschieht, wenn die Eingabe mit einem eingebetteten beginnt '\0'. Dann buffer[len -1] wird buffer[SIZE_MAX] Zugriff auf Speicher sicherlich außerhalb des legitimen Bereichs von buffer. Etwas, das ein Hacker ausprobieren oder finden könnte, wenn er UTF16-Textdateien dummerweise liest. Dies war der Stand einer Antwort, als diese Antwort geschrieben wurde. Später hat ein Nicht-OP es bearbeitet, um Code wie die Überprüfung dieser Antwort einzuschließen "".
```
size_t len = strlen(buffer);
if (buffer[len - 1] == '\n') {  // FAILS when len == 0
  buffer[len -1] = '\0';
}
```
sprintf(buffer,"%s",buffer); ist undefiniertes Verhalten: Ref. Außerdem werden keine führenden, trennenden oder nachgestellten Leerzeichen gespeichert. Jetzt gelöscht.

[Edit due to good later answer] Mit dem 1 Liner gibt es keine Probleme buffer[strcspn(buffer, "\n")] = 0; andere als die Leistung im Vergleich zu der strlen() sich nähern. Die Leistung beim Trimmen ist normalerweise kein Problem, da der Code E / A ausführt – ein schwarzes Loch der CPU-Zeit. Sollte der folgende Code die Länge der Zeichenfolge benötigen oder sehr leistungsbewusst sein, verwenden Sie dies strlen() sich nähern. Sonst die strcspn() ist eine gute Alternative.

Question 6

Direkt zum Entfernen des ‘\n’ aus der fgets-Ausgabe, wenn jede Zeile ‘\n’ enthält

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

Question 7

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

Question 8

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