Using fgets, removing last character

Hello,

I have ran into a slight problem. Of course I always did it the bad way I guess and now I'm looking for a solution. Here is my current code:

Code:

---

int main() {
        char sentence[256];

        printf("Enter your sentence here: ");
        fgets(sentence, 255, stdin);
        sentence[strlen(sentence)-1] = '\0';
       
        printf("Sentence: %s\n", sentence);
       
        return 0;
}

---

The only thing is, I don't like calling strlen() in that situtation. I've tried everything from *(sentence--) = '\0' to sentence[*sentence-1] = '\0' and I just can't seem to find a way.

To keep an open mind, is there actually a way or is this [current way] the best way?


Thank you for your time,
- Stack Overflow

fgets will automatically append the '\0' so long as there is no error in reading.

Quote:

---

Originally Posted by Perspective

fgets will automatically append the '\0' so long as there is no error in reading.

---

To add to this, this is why you should check the return value of your functions...

Quzah.

I agree,

Though in fact fgets returns a char * and when dealing with the function, or maybe even in Linux itself, my sentence I retrieve retrieves the '\n' at the end of the string for some strange reason.

I will look into this with more detail.

- Stack Overflow

Well a couple things to remember
1) fgets will get the '\n' if there is room
2) fgets will always append a null character
3) strlen returns the number of characters not counting the null character.

So if the input what "able" your string would be:
"able\n\0", strlen would return 5, 5 - 1 = 4, string[4] is '\n'

I see,

Thanks. A program I'm writing doesn't like the whole '\n' character, and my algorithm usually gets messed up if that happens, so I'm going to take another approach:

Code:

---

int main() {
        char sentence[256], *sent;

        printf("Enter your sentence here: ");
        sent = fgets(sentence, 255, stdin);
        sent[strlen(sentence) - 1] = '\0';
       
        printf("Sentence: %s\n", sent); // use sent instead of sentence from now on
       
        return 0;
}

---

That shouldn't conflict with sentence now, and the whole length of the string recursively calling itself. I thought there would be an easier way, but I guess this is the best way around it for now.


Thank you for your time,
- Stack Overflow

the reason that

Code:

---

*(sentence--) = '\0

---

doesn't work is because the memory address is at the beggining for strings. So sentence-- will be one before the actual string. It really is the best way, because either way you will have to get to the end of a string. if you want you could use (with caution)scanf

Code:

---

#include <stdio.h>
#include <stdlib.h>

int main(void){
        char string[100];
        printf("Enter a string\n");
        if(!scanf("%100s*[^\n]",string)){
                printf("Failure\n");
                return EXIT_FAILURE;
        }
        printf("%s",string);
        return EXIT_SUCCESS;
}

---

this won't get spaces though

Code:

---

if( (c=strrchr( buf, '\n' )) )
    *c='\0';

---

With, or without the r.

Quzah.

forgive me my ignorance but, in this case wouldnt it be easier to use gets instead of fgets?

Even though it dosnt have built in array overrun you could always just code in an if statement to tell it the last chr is null if it exceeds size and then you wouldnt have to worry about \n being in there and save your self a few clock cycles.

~Meloshski

To quote the header file I got with gcc

Quote:

---

Originally Posted by stdio.h

/* Get a newline-terminated string from stdin, removing the newline.
DO NOT USE THIS FUNCTION!! There is no limit on how much it will read.

---

That is in reference to gets, always use fgets over gets.

gets() is the one thing I have no problem saying: NEVER EVER USE IT. THERE IS NO EXCUSE FOR USING gets().

Quote:

---

Even though it dosnt have built in array overrun you could always just code in an if statement to tell it the last chr is null if it exceeds size and then you wouldnt have to worry about \n being there

---

Yeah, because you'd be too busy worrying about it crashing your program or causing a nice little security problem because someone used a buffer overrun to trash you OS or ...

Quzah.

Thanks everyone,

I too agree there is no possible excuse to use gets() for any compilation. Why they created these functions, hence gets() and fflush(), still comes unclear to me.

I like the method:

Code:

---

if( (c=strrchr( buf, '\n' )) )
    *c='\0';

---

It's the fastest, safest, and most reasonable approach in my view to remove the '\n' character from the string.


Once again thank you all, and thank you quzah,
- Stack Overflow

fflush is a useful function, however, people always use it wrong around these parts, trying to flus input streams instead of output...

Quzah.

Well fflush() has its usages like flushing the output buffer. Most likely gets() was implamented before fgets(). Now the question is why the still allow it to live :)

Quote:

---

Originally Posted by Thantos

Most likely gets() was implamented before fgets(). Now the question is why the still allow it to live :)

---

So you can still compile and run old crappy code. ;)

Quzah.

It should be a compile time error with a message like:

Quote:

---

What the hell are you thinking using gets(). Don't you know that the devil himself will raise up by using this function? Begone heathen!

---

Or something like that

Quote:

---

Originally Posted by Thantos

It should be a compile time error with a message like: Or something like that

---

It should just delete the file you're compiling. ;)

Quzah.

Wow,

This function must be hated world-wide ;) I'll be sure to never use it, even if bribed with the most amount of money immaginable. fgets() forever!

- Stack Overflow

Quote:

---

Originally Posted by Stack Overflow

I like the method:

Code:

---

if( (c=strrchr( buf, '\n' )) )
    *c='\0';

---

It's the fastest, safest, and most reasonable approach in my view to remove the '\n' character from the string.

---

I am not disagreeing with strrchr being safe and reasonable, but I do have a few comments on it being the fastest.

The call to strrchr may need to start at the beginning of the string, look for the null terminator, and then begin the backwards search for the newline. If it's there, you'll find it right away. If it isn't there, you'll have to go all the way back to the beginning of the string before it returns NULL.

Using strchr might be slow as well, because it looks for the newline and it looks for the terminating null for each character from beginning to the end.

When immedaitely following a call to fgets, the newline (if it is there) will be at the end right before the terminating null. Now since we know that the newline will only be at the end, why not just look there? Call strlen, back up one, and look for a newline. If it is there, replace it with a null.

This is a comparison thingy I'd written a while ago.

Code:

---

#include <stdio.h>
#include <string.h>
#include <time.h>

char *foo(char *s)
{
  size_t len = strlen(s);
  char *newline = s + len - 1;
  if ( *newline == '\n' )
  {
      *newline = '\0';
  }
  return s;
}

char *bar(char *s)
{
  char *newline = strrchr(s, '\n');
  if ( newline )
  {
      *newline = '\0';
  }
  return s;
}

char *baz(char *s)
{
  char *newline = strchr(s, '\n');
  if ( newline )
  {
      *newline = '\0';
  }
  return s;
}

char *qux(char *s)
{
  strtok(s, "\n");
  return s;
}

char *zed(char *s)
{
  size_t newline = strlen(s) - 1;
  if ( s [ newline ] == '\n' )
  {
      s [ newline ] = '\0';
  }
  return s;
}

#define BIND(j)  {j,#j}

int main(void)
{
  static const struct
  {
      char *(*call)(char*);
      const char *name;
  } function[] =
  {
      BIND(foo), BIND(bar), BIND(baz), BIND(qux), BIND(zed)
  };
  char text[][45] =
  {/* 01234567890123456789012345678901234567890123 */
      "All work and no play makes Jack a dull boy!\n",
      "The quick brown fox jumps over the lazy dog.",
  };
  size_t i,j,k;
  for ( i = 0; i < sizeof text / sizeof *text; ++i )
  {
      for ( j = 0; j < sizeof function / sizeof *function; ++j )
      {
        clock_t end, start;
        start = clock();
        for ( k = 0; k < 50000000; ++k )
        {
            text[0][43] = '\n';
            function[j].call(text[i]);
        }
        end = clock();
        printf("%s: %g, \"%s\"\n", function[j].name,
                (end - start) / (double)CLOCKS_PER_SEC,
                function[j].call(text[i]));
        fflush(stdout);
      }
      putchar('\n');
  }
  return 0;
}

/* my output
foo: 3.055, "All work and no play makes Jack a dull boy!"
bar: 3.835, "All work and no play makes Jack a dull boy!"
baz: 8.102, "All work and no play makes Jack a dull boy!"
qux: 16.884, "All work and no play makes Jack a dull boy!"
zed: 3.075, "All work and no play makes Jack a dull boy!"

foo: 3.174, "The quick brown fox jumps over the lazy dog."
bar: 9.654, "The quick brown fox jumps over the lazy dog."
baz: 8.202, "The quick brown fox jumps over the lazy dog."
qux: 17.014, "The quick brown fox jumps over the lazy dog."
zed: 3.105, "The quick brown fox jumps over the lazy dog."
*/

---

Naturally, your mileage may vary...

Quote:

---

foo: 13.16, "All work and no play makes Jack a dull boy!"
bar: 10.46, "All work and no play makes Jack a dull boy!"
baz: 10.84, "All work and no play makes Jack a dull boy!"
qux: 27.84, "All work and no play makes Jack a dull boy!"
zed: 12.87, "All work and no play makes Jack a dull boy!"

foo: 12.88, "The quick brown fox jumps over the lazy dog."
bar: 9.98, "The quick brown fox jumps over the lazy dog."
baz: 10.69, "The quick brown fox jumps over the lazy dog."
qux: 27.98, "The quick brown fox jumps over the lazy dog."
zed: 12.49, "The quick brown fox jumps over the lazy dog."


gcc (GCC) 3.2.3 (Debian)
Copyright (C) 2002 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

---

In my case, both times, strrchr is the fastest implementation.

Quzah.

>>strrchr is the fastest implementation
You really care about speed when processing a single line of user input?! :D

My "method of the moment" is to strtok() it. OK, it may be more of an overhead, but it saves typing, and shortens my source, and doesn't require validation (of course the fgets() call does though). ;)
>>strtok(input, "\n");

Well,

I do know for a fact:

Code:

---

if ((c = strrchr(sentence, '\n')))
            *c = '\0';

---

Sure is alot faster and safer than:

Code:

---

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

---

Or, at least I know that much now.


- Stack Overflow

Quote:

---

char *foo(char *s)
{
size_t len = strlen(s);
char *newline = s + len - 1;
if ( *newline == '\n' )
{
*newline = '\0';
}
return s;
}

---

The problem with that though is if the string has a length of 0 you will be working with an invalid index (-1).

Ah,

Yes I see that now. I never got the chance to try it but yeah -1 is an invalid index I believe. How does this implementation look, does it contain any flaws or is it any faster than strrchr() itself?

Code:

---

char* jar(const char *, int);
char* har(const char *, int);

int main() {
        char *c;
        char sentence[25] = "Testing\n";
        char sentence2[15] = "Testing\n";

        if (c = jar(sentence, '\n'))
                *c = '\0';

        if (c = har(sentence2, '\n'))
                *c = '\0';

        return 0;
}

char* jar(const char *string, int c) {
        char *s, cc = c;
        char *sp = (char *)0;

        s = (char *)string;

        while (*s) {
                if (*s == cc)
                        sp = s;
                s++;
        }
        if (cc == 0)
                sp = s;

        return sp;
}

char* har(const char *string, int c) {
        char *pch = 0;

        while( *string ) {
                if( *string == c )
                        pch = (char *)string;
                string++;
        }

        return (char *)pch;
}

---

Thank you for your time,
- Stack Overflow

Quote:

---

Originally Posted by Sebastiani

The problem with that though is if the string has a length of 0 you will be working with an invalid index (-1).

---

Nice catch on that one. Because it is perfectly legal to use the function like so:

Code:

---

foo( "" );

---

:)

Which interestingly enough, gives me the following output, in addition to the above:

Quote:

---

foo: 3.32, ""
bar: 1.7, ""
baz: 1.44, ""
qux: 4.08, ""
zed: 2.27, ""

---

It doesn't crash though. So at least that's good. ;) Oddly in this case, strchr beats strrchr. :D


Quzah.

Quote:

---

Originally Posted by Dave_Sinkula

When immedaitely following a call to fgets

---

Quote:

---

Originally Posted by Sebastiani

The problem with that though is if the string has a length of 0 you will be working with an invalid index (-1).

---

I was aware of that. I just hadn't come up with a way of having fgets not return NULL but have an empty string, although I guess I hadn't tried passing it a 1-character "string". An empty line, "\n", will be 1 character long.

>>foo( "" );
>>It doesn't crash though. So at least that's good.
Lucky more like :D Modifying string literals is a no no.

@Stack Overflow: If all you're looking for is a quick way to terminate a string at the first occurence of a particular character (which is what the "strip newline" type functions you've created do), try this:

Code:

---

#include <stdio.h>
 
 void foo(char *s, int c)
 {
  while (*s && *s != c)
  {
    s++;
  }
 
  *s = '\0';
 }
 
 int main(void)
 {
  char  n[] = "blahh\n";
  char  m[] = "\n";
 
  printf("n after >%s<\n", n);
  foo(n, '\n');
  printf("n after >%s<\n", n);
 
  printf("m before >%s<\n", m);
  foo(m, '\n');
  printf("m after >%s<\n", m);
 
  return(0);
 }

---

Wow,

That looks cool. Thanks again, and it looks just like what I needed. (I think) ;)

Well, this topic has saved me lots of time trying to remove that '\n' out of my sentence. Can't believe I didn't think about a simple 5 liner code:

Code:

---

void foo(char *s, int c) {
        while (*s && *s != c)
                s++;
        *s = '\0';
}

---

And simple too! :)


Thanks all for your help,
- Stack Overflow

Quote:

---

Originally Posted by Hammer

>>foo( "" );
>>It doesn't crash though. So at least that's good.
Lucky more like :D Modifying string literals is a no no.

---

Actually I'd modified the example to have another line in the array of text being passed it so it had a string like that.

Code:

---

char text[][45] =
  {/* 01234567890123456789012345678901234567890123 */
      "All work and no play makes Jack a dull boy!\n",
      "The quick brown fox jumps over the lazy dog.",
      "",
  };

---

Quzah.

>>I'd modified the example
Ahh, I see. I should've read code closer :rolleyes:

>>a simple 5 liner code
Dude, your cut/paste is up the spout, there's a brace missing from that snippet! :D

My bad.