Removendo o caractere de nova linha à direita da entrada fgets ()

Estou tentando obter alguns dados do usuário e enviá-los para outra função no gcc. O código é algo como isto.

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

No entanto, acho que ele tem um \ncaractere de nova linha no final. Então, se eu entrar John, acaba enviando John\n. Como faço para remover isso \ne enviar uma string adequada.

A maneira um pouco feia:

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

A maneira um pouco estranha:

strtok(Name, "\n");

Observe que a strtokfunção não funciona como esperado se o usuário digitar uma string vazia (ou seja, pressionar apenas Enter). Deixa o \npersonagem intacto.

Existem outros também, é claro.

Talvez a solução mais simples use uma das minhas funções pouco conhecidas favoritas strcspn():

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

Se você deseja que ele também manipule '\r'(por exemplo, se o fluxo for binário):

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

A função conta o número de caracteres até atingir a '\r'ou a '\n'(em outras palavras, encontra o primeiro '\r'ou '\n'). Se não acertar nada, ele pára no '\0'(retornando o comprimento da corda).

Observe que isso funciona bem, mesmo se não houver nova linha, porque strcspnpara em a '\0'. Nesse caso, a linha inteira está simplesmente substituindo '\0'por '\0'.

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

Abaixo está uma abordagem rápida para remover um potencial '\n'de uma string salva por fgets().
Utiliza strlen(), com 2 testes.

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

Agora use buffere lenconforme necessário.

Este método tem o benefício colateral de um lenvalor para o código subseqüente. Pode ser facilmente mais rápido que strchr(Name, '\n'). Ref YMMV, mas ambos os métodos funcionam.

buffer, do original fgets()não conterá em "\n"algumas circunstâncias:
A) A linha era muito longa para bufferque apenas o charanterior '\n'seja salvo em buffer. Os caracteres não lidos permanecem no fluxo.
B) A última linha do arquivo não terminou com a '\n'.

Se a entrada incorporou caracteres nulos '\0'em algum lugar, o comprimento relatado por strlen()não incluirá o '\n'local.

Problemas de outras respostas:

1. strtok(buffer, "\n");falha ao remover o '\n'quando bufferé "\n". A partir desta resposta - alterada após esta resposta para avisar sobre esta limitação.

2. O seguinte falha em raras ocasiões, quando a primeira charleitura fgets()é '\0'. Isso acontece quando a entrada começa com um incorporado '\0'. Então buffer[len -1]torna-se buffer[SIZE_MAX]acessar a memória certamente fora da faixa legítima de buffer. Algo que um hacker pode tentar ou encontrar na leitura tola de arquivos de texto UTF16. Esse era o estado de uma resposta quando essa resposta foi escrita. Posteriormente, um não-OP editou-o para incluir um código como o de verificação desta resposta "".

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

3. sprintf(buffer,"%s",buffer);é um comportamento indefinido: ref . Além disso, ele não salva nenhum espaço em branco inicial, separador ou final. Agora excluído .

4. [Editar devido a uma boa resposta posterior ] Não há problemas com o liner 1 buffer[strcspn(buffer, "\n")] = 0;além do desempenho em comparação com a strlen()abordagem. O desempenho no corte geralmente não é um problema, pois o código está executando a E / S - um buraco negro no tempo da CPU. Se o código a seguir precisar do comprimento da string ou tiver alto desempenho, use esta strlen()abordagem. Caso contrário, strcspn()é uma boa alternativa.

Direto para remover '\ n' da saída do fgets, se todas as linhas tiverem '\ n'

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

De outra forma:

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

Para um corte único \ \ n,

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

para vários cortes \ \ n ',

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

My Newbie way ;-) Por favor, deixe-me saber se isso está correto. Parece estar funcionando para todos os meus casos:

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

As etapas para remover o caractere de nova linha da maneira talvez mais óbvia:

1. Determine o comprimento da string dentro NAMEusando strlen(), header string.h. Observe que strlen()não conta a terminação \0.

size_t sl = strlen(NAME);

2. Veja se a sequência começa com ou inclui apenas um \0caractere (sequência vazia). Nesse caso slseria 0porque, strlen()como eu disse acima, não conta \0e para na primeira ocorrência:

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

3. Verifique se o último caractere da sequência correta é um caractere de nova linha '\n'. Se for esse o caso, substitua \npor a \0. Observe que as contagens de índice começam em, 0portanto, precisaremos NAME[sl - 1]:

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

Observe que se você pressionar Enter apenas na fgets()solicitação de sequência (o conteúdo da sequência era composto apenas por um caractere de nova linha), a sequência NAMEserá uma sequência vazia posteriormente.

4. Podemos combinar os passos 2. e 3. juntos em apenas um if declaração usando o operador lógico &&:

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

5. O código finalizado:

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

Se você preferir uma função para usar essa técnica, manipulando as fgetsseqüências de saída em geral sem redigitar todas as vezes, aqui está 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';
    }
}

No seu exemplo fornecido, seria:

printf("Enter your Name: ");

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

Observe que esse método não funciona se a string de entrada tiver incorporado \0 s . Se fosse esse o caso strlen(), retornaria apenas a quantidade de caracteres até o primeiro \0. Mas essa não é uma abordagem comum, já que as funções de leitura de cordas geralmente param na primeira\0 e levam a string até esse caractere nulo.

Além da pergunta por si só. Tente evitar negações duplas que tornam a sua unclearer código: if (!(fgets(Name, sizeof Name, stdin) != NULL) {}. Você pode simplesmente fazer if (fgets(Name, sizeof Name, stdin) == NULL) {}.

Tim Čas um liner é incrível para seqüências de caracteres obtidas por uma chamada para fgets, porque você sabe que elas contêm uma única nova linha no final.

Se você estiver em um contexto diferente e quiser manipular seqüências de caracteres que possam conter mais de uma nova linha, talvez esteja procurando por strrspn. Não é POSIX, o que significa que você não o encontrará em todos os Unices. Eu escrevi um para minhas próprias necessidades.

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

Para quem procura um equivalente Perl chomp em C, acho que é isso (o chomp remove apenas a nova linha à direita).

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

A função 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 usar getlineé uma opção - não negligenciando seus problemas de segurança e se você deseja colocar ponteiros - você pode evitar as funções de cadeia, pois getlineretorna o número de caracteres. Algo como abaixo

#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 : Os [ problemas de segurança ] com getlinenão devem ser negligenciados.}

A função abaixo faz parte da biblioteca de processamento de strings que estou mantendo no Github. Remove caracteres indesejados de uma string, exatamente o que você deseja

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

Um exemplo de uso pode ser

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

Você pode verificar outras funções disponíveis ou até contribuir com o projeto :) https://github.com/fnoyanisi/zString

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

Você deveria tentar. Esse código basicamente percorre a string até encontrar o '\ n'. Quando encontrado, '\ n' será substituído pelo terminador de caracteres nulos '\ 0'

Observe que você está comparando caracteres e não seqüências de caracteres nesta linha, então não há necessidade de usar strcmp ():

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

pois você usará aspas simples e não aspas duplas. Aqui está um link sobre aspas simples vs duplas, se você quiser saber mais

Tente este:

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