Thread: Removing Leading & Trailing Whitespace

Check out the memmove() function.

Basically you do:

Code:

char *realstart = string + num_leading_spaces; // Pointer to first non-space character

memmove(string, realstart, strlen(realstart) + 1);

The problem is that you're using a string that's not modifiable. Try changing:

Code:

char *mychr = "    see spot   see";

to:

Code:

char mychr[] = "   see spot   see";

The first way just creates a pointer to a string literal which is stored in read-only memory (on most systems). The second way creates an array in which the string is copied. The array contents are modifiable.

EDIT: By the way, your usage of memmove() itself looks fine. It's just that the pointers that you're passing to memmove() point to read-only memory.

Code:

while (*start && *start == ' ') start++;

The first condition is unnecessary. If *start is a space then there's no need to check if *start is non-zero. I'd just do:

Code:

while (*start == ' ') start++;

Code:

while (*end && *end == ' ') end--;

You're working backwards through the string so *end will never be zero (as long as you're still pointing to somewhere within the string). Instead you want to make sure that end is greater than inputStr to avoid running past the beginning of the string. I'd write it like:

Code:

while (end >= inputStr && *end == ' ') end--;

And just for efficiency you might want to avoid calling strlen() twice. You could create a size_t len and set that just before the memmove(). Then you could pass len to memmove() and use it in the calculation for your end pointer.

Also, sometimes it's helpful, if your function isn't going to return anything else, to return a pointer to the finished string. Sort of like strcpy() and the rest of the standard string functions do.

Looks good though!

My finished function, if I were to write it, would probably look like:

Code:

char *stripWhitespace (char *inputStr)
{
  char *start, *end;
  size_t len;

  /* Strip leading whitespace */
  start = inputStr;
  while(*start == ' ') start++;
  len = strlen(start);
  memmove(inputStr, start, len + 1);

  /* Strip trailing whitespace */
  end = inputStr + len - 1;
  while(end >= inputStr && *end == ' ') end--;
  *(end + 1) = '\0';

  return inputStr;
}

I usually tend to handle constant string parsing with a struct, such that I maintain two endpoints. I seldom use the standard C runtime string handling, because this technique is far superior.

The beauty of doing things like this is that I can chew up and pass around substrings from very large sets of input data without moving any memory around, or allocating any memory. It's fairly easy to write even an entire XML parser this way that never allocates a thing, and only (recursively) passes around pointers to its self as it finds the ends of fields within the file.

Code:

typedef struct cstr
{
    const char* begin; /* Beginning of string */
    const char* end;    /* End of string */
} cstr;

/* Initialization from various scenarios... */
#define cstr_ptr( cstr, sz )  \
{ \
   (cstr)->begin = (cstr)->curr = (sz); \
   (cstr)->end = (cstr)->begin + strlen((cstr)->begin); \
}

/* How big is a cstr */
#define cstr_len( cstr )  ( (cstr)->end - (cstr)->begin )

/* Strip white space from either end of string */
void cstr_stripwhite( cstr* self )
{
   const char* begin = self->begin;
   const char* end = self->end;
   while( begin < end && isspace(*begin) )
      begin++;
   while( end > begin && isspace(*(end-1) )
      end--;
   self->begin = begin;
   self->end = end;
}

Of course, if you don't want to do this whole structured approach, do keep in mind that you can go a long way with changing a pointer (such as a pointer to the beginning of a string), rather than moving data around, which can be very time consuming.

Added...
(Of course, the actual code I use is a macro template that swaps out char/wchar_t/etc. functions and manufactures the appropriate string handlers....)

What's with all the "evil" people in this topic?

Anyway, as far as I can tell, that's a pretty damn good first post evildave. *claps*

One suggestion I would make is that "whitespace" includes other characters as well, such as horizontal tab and linefeed. For this reason I would replace direct comparisons to ' ' with a call to isspace(), like evildave did.

While you may only want to strip space characters today, later you may want to use it to strip any whitespace...

What's with all the "evil" people in this topic?

It is a well known fact that a common enemy to all evil people is whitespace, as it is the one thing that stands between well obfuscated code.

I really do like your object orientated approach, evildave and will try to keep it up. On a side note the function was not meant to be void, I am planning to making it return the number of chars that it stripped (but just have not got round to do doing it yet).

Thanks for all of your help guys.

*EDIT* A quick question about memmove, inputStr is == to start will it actually bother to move the memory or will it realise that there is no point as both pointers point to the same place?