remove white space

Hello

I have a char str[100] which contains a sequence of characters with a blank space at the end.
I want to remove the blank space.

EX:
str contains: "Pokemons are great "
I want to change it to
"Pokemons are great"

Notice that the string doesn't end with a white space.

What function can do this?

Thanks.

start with the last char
while(this is white space) put '\0'

write a loop to copy all the bytes above space symbol to the lower index, sample:
for (i = spaceIndex; i <= strlen(str); i++)
str[i] = str[i] + 1;
str[strlen(str) - 2] = 0; //string end symbol

Don't really get what you mean that it doesn't end with a whitespace since you say it ends with a space.

Anyhow, the string ends with '\0' always. So to delete a character you can put a '\0' where you want the string to end. Thus to eliminate the space at the end:

Code:

---

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

---

Quote:

---

Originally Posted by baccardi

write a loop to copy all the bytes above space symbol to the lower index, sample:
for (i = spaceIndex; i <= strlen(str); i++)
str[i] = str[i] + 1;
str[strlen(str) - 2] = 0; //string end symbol

---

you need no copy to get rid of trailing spaces...

Code:

---

$ cat str.c
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main ()
{
 char str[100] = "Pokemons are great ";
 int len;


 len = (int) strlen(str);

 printf("str before [%s], len[%d]\n", str, len);

 len--;
 while (isspace(*(str + len) )) {
      len--;
 }

 *(str + len + 1) = '\0';

 printf("str after [%s], len[%d]\n", str, (int) strlen(str));

 exit (0);
}

$ gcc -Wall str.c
$ a.out
str before [Pokemons are great ], len[19]
str after [Pokemons are great], len[18]

---

thanks

I once did that myself. Note that the version above fails for strings consisting only of whitespaces that reside at memory locations with whitespaces just before the start of a string.

Code:

---

/* Remove leading whitespaces */
char *ltrim(char *const s)
{
        size_t len;
        char *cur;

        if(s && *s) {
                len = strlen(s);
                cur = s;

                while(*cur && isspace(*cur))
                        ++cur, --len;

                if(s != cur)
                        memmove(s, cur, len + 1);
        }

        return s;
}

/* Remove trailing whitespaces */
char *rtrim(char *const s)
{
        size_t len;
        char *cur;

        if(s && *s) {
                len = strlen(s);
                cur = s + len - 1;

                while(cur != s && isspace(*cur))
                        --cur, --len;

                cur[isspace(*cur) ? 0 : 1] = '\0';
        }

        return s;
}

/* Remove leading and trailing whitespaces */
char *trim(char *const s)
{
        rtrim(s);
        ltrim(s);

        return s;
}

---

Greets,
Philip

From what I see, rtrim() can be simplified to:

Code:

---

/* Remove trailing whitespaces */
char *rtrim(char *const s)
{
        if(s && *s) {
                char *cur = s + strlen(s) - 1;

                while(cur != s && isspace(*cur))
                        --cur;

                cur[isspace(*cur) ? 0 : 1] = '\0';
        }

        return s;
}

---

Good point! Looks like I did copy and paste from ltrim().

Thanks,
Philip

Quote:

---

Originally Posted by Snafuist

Looks like I did copy and paste from ltrim().

---

Heheh, but a thought just crossed my mind: maybe we could use a similiar idea to simplify ltrim(), e.g.,

Code:

---

/* Remove leading whitespaces */
char *ltrim(char *const s)
{
        if(s && *s) {
                char *cur = s;

                while(*cur && isspace(*cur))
                        ++cur;

                if(s != cur)
                        memmove(s, cur, strlen(cur) + 1);
        }

        return s;
}

---

There is also the possibility of replacing this:

Code:

---

cur[isspace(*cur) ? 0 : 1] = '\0';

---

with:

Code:

---

cur[!isspace(*cur)] = '\0';

---

but it is quite possibly more obfuscation than simplification.

Quote:

---

Originally Posted by laserlight

There is also the possibility of replacing this:

Code:

---

cur[isspace(*cur) ? 0 : 1] = '\0';

---

with:

Code:

---

cur[!isspace(*cur)] = '\0';

---

but it is quite possibly more obfuscation than simplification.

---

that only works if isspace returns 0 or 1, and it doesn't have to because any non-zero value counts as true.

Quote:

---

Originally Posted by Meldreth

that only works if isspace returns 0 or 1, and it doesn't have to because any non-zero value counts as true.

---

No, it works if isspace returns zero or non-zero (which is as defined in the C standard), since the logical negation causes zero to become one and non-zero to become zero.

One more attempt at squeezing some improvement from Snafuist's examples: I am not sure if this is a simplification, an obfuscation, or both, but it is a very micro-optimisation to replace this:

Code:

---

while(*cur && isspace(*cur))
        ++cur;

---

with:

Code:

---

while(isspace(*cur) && *++cur);

---

EDIT:
Oh, and we can replace memmove() with:

Code:

---

char *dest = s;
while ((*dest++ = *cur++));

---