Thread: Remove space in a string

Not to mention the fact that modern compilers are pretty handy at optimizing a good deal of the time.

Quzah.

Originally Posted by nonpuz

of course you could use sizeof too.

No you can't. You can only use sizeof on an object that has been created in scope. Thus:

Code:

void foo( char * bar )
{
    char foobar[BUFSIZ];
    int x = sizeof( foobar ); /* valid */
    int y = sizeof( bar ); /* invalid */
}

Quzah.

Code:

while (isspace((unsigned char)*end)) {
    --end;
  }
  *++end = '\0';
  p = mem;
  while (isspace((unsigned char)*p)) {
    ++p;
  }

Well there are a few things:
1) There is no need to typecast this pointer. And if you're going to do so, then it should be done correctly. isspace expects an int, not an unsigned char. It's doubly wrong do use an unsigned char, because in doing so, you're changing the char to something else, because the sign bit is being treated differently than it normally would. It's best to leave it alone, and let it be auto-converted to an int when it's passed.

2) The end pointer is set initially to the end of the string. Then, as long as it's a white space character, the pointer is decremented until it reaches a character that is no longer white space. Once that character is reached, the pointer is incremented to the space beyond it, to the last white space character. It then is set to null, as to terminate the string.

3) The p pointer is set to the beginning of the string, and the same thing is done there, only advancing from the front, instead of from the back. However, this time you don't do anything to the string, you're just ignoring all preceeding white space.

Quzah.

The question isn't about the type.

Of coruse it's about type. Typecasting a char to an unsigned char is the wrong type. You're unsigning a value that is signed. That's wrong. That's what I said was wrong. What happens is what I said happens:

1)The signed char is typecast to an unsigned value. This screws with the signed bit, changing the value.
2) The new value is then auto cast to an int.

The cast to unsigned char forces the value of a character into the correct range on systems where char is signed.

No. That's wrong. Forcing the character to unsigned does not change "correct" the value. There is [b]never[/color] a reason to typecast to an unsigned character for these functions. If it is a char, it will auto promote to an integer. That's normal. That's what it's meant to do. Making it unsigned just screws it up.

Quzah.

I haven't been following too closely, but I believe this is the argument [edit](in favor of the cast)[/edit].

It's not a very good argument. For starters, EOF cannot be mapped to an unsigned value, because it is a negative number so I fail to see the purpose of the mapping. It's already determined that the is* functions will:

"C: A Reference Manual, 5th Edition"

All of the facilities described here operate properly on all values representable as type char or type unsigned char, and also on the value of EOF, but are undefined for all other integer values unless the indivudual description states otherwise.

So again, there is no purpose for the cast. It does nothing benificial, especially since the function takes an int as an argument anyway. The point would be, that were you to have a signed value for type char, and you cast it to unsigned char, it would distort the passed value from what it actually was.

Quzah.

Well, considering that the only required supported characters are the 128 ASCII characters, it wouldn't matter if it was signed, since they all fall in the first seven bits of a signed char implementation.

Quzah.

This is a simple, quick and dirty solution, but it works. It replaces any spaces greater than one with a single place, so I'm sure you could implement an array and delete all spaces that are at the beginning and end of a string with ease.

Here's the code:

Code:

#include <stdio.h>

int main()
{
	int c, copy;

	while((c = getchar()) != EOF){
		if(c == ' '&& copy == ' ') continue;
		else putchar(c);
		copy = c;
	}
	return 0;
}

So, as I was saying, by throwing in an array, and throwing in another loop (up to you) and swapping out the use of putchar, you should be able to easily accomplish this.

Not necessarily the best way to do it, but I haven't slept in a while. :P

Oh, forgot to mention that the EOF in this program (in windows xp) is read as CTRL+Z - so if you were wondering how to exit, that's how.