Удаление завершающего символа новой строки из ввода fgets ()

Я пытаюсь получить некоторые данные от пользователя и отправить их в другую функцию в gcc. Код примерно такой.

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

Тем не менее, я обнаружил, что \nв конце он имеет символ новой строки . Так что, если я вхожу, Johnэто заканчивается отправкой John\n. Как мне удалить это \nи отправить правильную строку.

Немного безобразный способ:

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

Немного странный способ:

strtok(Name, "\n");

Обратите внимание, что strtokфункция не работает должным образом, если пользователь вводит пустую строку (т.е. нажимает только Enter). Это оставляет \nперсонажа нетронутым.

Конечно, есть и другие.

Возможно, самое простое решение использует одну из моих любимых малоизвестных функций strcspn():

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

Если вы хотите, чтобы он также обрабатывал '\r'(скажем, если поток двоичный):

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

Функция считает количество символов до тех пор, пока не достигнет a '\r'или a '\n'(другими словами, она найдет первый '\r'или '\n'). Если он ничего не ударил, он останавливается на '\0'(возвращая длину строки).

Обратите внимание, что это работает нормально, даже если нет новой строки, потому что strcspnостанавливается на '\0'. В этом случае вся строка просто заменяется '\0'на '\0'.

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

Ниже приведен быстрый подход к удалению потенциала '\n'из строки, сохраненной с помощью fgets().
Используется strlen()с 2-мя тестами.

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

Теперь используйте bufferи по lenмере необходимости.

Этот метод имеет побочное преимущество lenзначения для последующего кода. Это может быть легко быстрее, чем strchr(Name, '\n'). Реф YMMV, но оба метода работают.

buffer, из оригинала fgets()не будет содержаться "\n"при некоторых обстоятельствах:
A) слишком длинная строка, bufferпоэтому сохраняется только charпредшествующее . Непрочитанные символы остаются в потоке. Б) Последняя строка в файле не заканчивается на . '\n'buffer
'\n'

Если во входных данных есть где-то встроенные нулевые символы '\0', длина, указанная пользователем strlen(), не будет включать '\n'местоположение.

Некоторые другие ответы на вопросы:

1. strtok(buffer, "\n");не удается удалить, '\n'когда bufferесть "\n". Из этого ответа - исправлены после этого ответа, чтобы предупредить об этом ограничении.

2. Следующий сбой в редких случаях , когда первое charчтение на fgets()это '\0'. Это происходит, когда ввод начинается со встроенного '\0'. Тогда buffer[len -1]становится buffer[SIZE_MAX]доступ к памяти определенно за пределами законного диапазона buffer. Что-то хакер может попробовать или найти в глупом чтении текстовых файлов UTF16. Это было состояние ответа, когда этот ответ был написан. Позже не-OP отредактировал его, включив в него код, подобный проверке этого ответа "".

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

3. sprintf(buffer,"%s",buffer);не определено поведение: Ref . Кроме того, он не сохраняет начальные, разделительные или конечные пробелы. Сейчас удалено .

4. [Изменить из-за хорошего последующего ответа ] С 1 вкладышем нет проблем, buffer[strcspn(buffer, "\n")] = 0;кроме производительности по сравнению с strlen()подходом. Производительность при обрезке обычно не является проблемой, учитывая, что код выполняет ввод-вывод - черная дыра процессорного времени. Если следующий код нуждается в длине строки или имеет высокую производительность, используйте этот strlen()подход. Иначе strcspn()это прекрасная альтернатива.

Прямое удаление \ n из вывода fgets, если в каждой строке есть \ n

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

В противном случае:

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

Для одиночной обрезки \ n

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

для многократной обрезки \ n

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

Мой путь новичка ;-) Пожалуйста, дайте мне знать, если это правильно. Кажется, работает для всех моих случаев:

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

Шаги по удалению символа новой строки, возможно, наиболее очевидным способом:

1. Определите длину строки внутри NAME, используя strlen()заголовок string.h. Обратите внимание, что strlen()не считается окончание \0.

size_t sl = strlen(NAME);

2. Посмотрите, начинается ли строка с или содержит только один \0символ (пустая строка). В этом случае slбудет, 0поскольку, strlen()как я сказал выше, не учитывается \0и останавливается при первом появлении этого:

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

3. Проверьте, является ли последний символ правильной строки символом новой строки '\n'. Если это так, замените \nна \0. Обратите внимание, что индекс начинается с 0того, что нам нужно сделать NAME[sl - 1]:

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

Обратите внимание, что если вы только нажали Enter при fgets()запросе строки (содержимое строки состояло только из символа новой строки), строка NAMEпосле будет пустой строкой.

4. Мы можем объединить шаги 2. и 3. вместе в одном ifвыражении, используя логический оператор &&:

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

5. Готовый код:

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

Если вы предпочитаете функцию для использования этой техники, обрабатывая fgetsвыходные строки в целом, не перепечатывая каждый раз, вот 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';
    }
}

В приведенном вами примере это будет:

printf("Enter your Name: ");

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

Обратите внимание, что этот метод не работает, если во входную строку встроены \0s. В этом случае strlen()будет возвращаться только количество символов до первого \0. Но это не совсем обычный подход, так как большинство функций чтения строк обычно останавливаются на первом \0и принимают строку до этого нулевого символа.

Помимо вопроса сам по себе. Старайтесь избегать двойных отрицаний , которые делают ваш код unclearer: if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Вы можете просто сделать if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Tim Čas один вкладыш удивителен для строк, полученных при вызове fgets, потому что вы знаете, что в конце они содержат одну новую строку.

Если вы находитесь в другом контексте и хотите обрабатывать строки, которые могут содержать более одной новой строки, возможно, вы ищете strrspn. Это не POSIX, то есть вы не найдете его на всех Unices. Я написал один для своих нужд.

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

Для тех, кто ищет Perl-аналог chomp в C, я думаю, что это так (chomp удаляет только завершающий перевод строки).

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

Функция 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;
}

Если вы используете getlineопцию - не пренебрегая ее проблемами безопасности и если вы хотите заключить указатели в скобки - вы можете избежать строковых функций, поскольку они getlineвозвращают количество символов. Что-то вроде ниже

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

^{Примечание : не следует пренебрегать [ проблемами безопасности ] с getline.}

Приведенная ниже функция является частью библиотеки обработки строк, которую я поддерживаю на Github. Он удаляет и нежелательные символы из строки, именно то, что вы хотите

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

Пример использования может быть

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

Вы можете проверить другие доступные функции или даже внести свой вклад в проект :) https://github.com/fnoyanisi/zString

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

Вы должны попробовать. Этот код в основном перебирает строку, пока не найдет \ n. Когда он будет найден, \ n будет заменен нулевым символом-терминатором

Обратите внимание, что вы сравниваете символы, а не строки в этой строке, поэтому нет необходимости использовать strcmp ():

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

так как вы будете использовать одинарные кавычки, а не двойные кавычки. Вот ссылка на одиночные и двойные кавычки, если вы хотите узнать больше

Попробуй это:

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