在C中删除带有字符串修剪的空格，换行符和制表符

Question

I was trying to gather sources from the internet to understand how it works and functions. Basically, I will need to check a space, newline, and tabs every time that it reads a string. So I made a function that takes care of that case:

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

static int  isspace(char c)
{
    return (c == '\t' || c == '\n' || c == ' ');
}

Then, I use the function below to implement it in ANOTHER function

char *my_strtrim(char const *string)
{
    char *i;
    char *s;
    int ready;

    i = s;
    s = (char *)string;
    ready = 0;
    while(*i)
    {
        ++i;
        if(isspace(*i))
        {
            if(!ready)
            {
                continue ;
            }
            ready = 0;
        }
        ready = 1;
        *(s++) = *i;
    }

    *s = 0;
    return ((char *)string);
}

For my main, I just made a random test case where it takes care of spaces, tabs, and newline:

int main()
{
    char str[] = "                      hello world\n !";
    printf("%s",my_strtrim(str));
}

There is an output error that there an error in my_strtrim function with i = s because s is has no result of NULL . The error says:

my_strtrim.c: error: variable 's' is uninitialized when used here [-Werror,-Wuninitialized]
        i = s;
            ^
my_strtrim.c: note: initialize the variable 's' to silence this warning
        char *s;
               ^
                = NULL

After I fix what it says (making s = NULL ) I get a segmentation fault. This problem has become confusing because it works fine as a for-loop, but not as a while loop. I am required to do this problem as a while-loop.

SOLUTION My friend gave me a little tip/rule of thumb, which is keeping code simple and nice to understand. I had a single cluster function doing a lot of things in the same; therefore, I was getting confused. He guided me and told me to make me to condense my whole function into little pieces.

STEP 0: Initilize variables and declare

Self explanatory

STEP 1: GET POSITION OF YOUR POINTER STRING

 int step1_getPosition(char const *string) { int i; i = 0; while(my_iswhitespace(string[i])) { i++; continue; } return (i); } 

STEP 2: COPY YOUR STRING

 char *step2_copyString(char const *string, int pos) { char *tmp; int i; i = 0; tmp = my_strnew(my_strlen(string)); if(tmp == NULL) return (NULL); while (string[pos] != '\\0') tmp[i++] = string[pos++]; return (tmp); } 

STEP 3: REMOVE WHITE SPACES

 char *step3_removeWhite(char *str) { int i; i = my_strlen(str); while (str[i] == '\\0' || my_iswhitespace(str[i])) { str[i] = '\\0'; i--; } return (str); } 

STEP 4: REMOVE EXTRA NULL-BYTES ('\\0')

 char *step4_removeExtraNulls(char *str) { char *newstring; newstring = my_strdup(str); if(newstring == NULL) return (NULL); free(str); return (newstring); } 

STEP 5: MAIN FUNCTION CALLED WITH THE OTHER FUNCTIONS CREATED

 char *my_strtrim(char const *string) { char *trim; int i; i = step1_getPosition(string); trim = step2_copyString(string, i); if (trim == NULL) return (NULL); step3_removeWhite(trim); trim = step4_removeExtraNulls(trim); if (trim == NULL) return (NULL); return (trim); } 

The output I get is: hello world ! Which this is correct

Answer 1

The simplest way to "trim" leading white-space characters, is to just skip over them, not to modify the string at all.

This relies on the fact that a "string" in C can be expressed as a pointer to a sequence of null-terminated characters.

Take for example your string

char str[] = "                      hello world\n !";

If we let the array str decay to a pointer to its first element, it points to the first space. What if we had a pointer that pointed to the 'h' instead? That would be an equally valid "string".

To get that pointer, we just loop over the string, as long as the current character is a space (and not the terminator of course).

Putting this into practice we get

char *my_strtrim(char const *string)
{
    for (/* empty */; *string && my_isspace(*string); ++string)
    {
        // Empty
    }

    return string;
}

After the loop in the function above, the pointer string will point either to the terminator (if the string was just all space), or to the first non-space character in the string.

If we use it like

printf("%s\n", my_strtrim(str));

then it will print

hello world
 !

_{[The embedded newline is because you have it in your string.]}

It should be noted that this doesn't trim trailing spaces. For that to be possible, the argument string can't be a pointer to constant characters.

Answer 2

The problem is happening because when yo're assigning the i = s the s variable is in an undefined condition.

Please, consider the below code:

char *my_strtrim(char const *string)
{
    char *i;
    char *s;
    int ready;

    s = (char *)string;
    i = s;
    ready = 0;
    while(*i)
    {
        ++i;
        if(isspace(*i))
        {
            if(!ready)
            {
                continue ;
            }
            ready = 0;
        }
        ready = 1;
        *(s++) = *i;
    }

    *s = 0;
    return ((char *)string);
}

Answer 3

Zeid, continuing from the comments. One of the efficiency goals should be to limit the number of passes you make over the string (optimally to one). You should also consider passing a final array to hold the trimmed string, as there are many instances where the original will need to be preserved, or, as correctly noted by Some programmer dude, you cannot modify and parameter specified as const or one that resides in read only memory (such as a string literal ).

You can use a VLA for that purpose in the caller. Putting that altogether and adding an additional parameter to hold the result, 'r' below, you could do something like the following.

It simply removes all leading whitespace, then backs up, removing all trailing whitespace, and checks whether the final character is anything other than an alnum character (since most sentences end with some type of punctuation). It then checks whether there is any additional whitespace between the punctuation and the last alnum char in the string removing any intervening whitespace by shuffling the end characters forward to overwrite any intervening whitespace found (this will get rid of your extra '\\n ' between world and '!' )

#include <stdio.h>
#include <ctype.h>

/** remove leading and trailing whitespace, original is preserved.
 *  this funciton can be used with or without assigning return.
 *  any intervening whitespace between end punctuation and first
 *  alpha-num character is also removed.
 */
char *strtrimws (char *r, const char *s)
{
    char *p = r;                            /* pointer to result         */
    *r = 0;                                 /* initialize as empty str   */
    if (!s) return NULL;                    /* validaate source str      */
    if (!*s) return r;                      /* empty str - nothing to do */
    while (isspace (*s))  s++;              /* skip leading whitespace   */
    while (*s) *p++ = *s++;                 /* fill r with s to end      */
    *p = 0;                                 /* nul-terminate r           */
    while (p > r && isspace (*--p)) *p = 0; /* overwrite spaces from end */
    while (p > r && !isalnum (*--p)) {      /* continue until 1st alnum  */
        if (isspace (*p)) {                 /* if spaces found           */
            char *rp = p, *wp = p;          /* set read & write pointers */
            while (*rp++) *wp++ = *rp;      /* shuffle end chars forward */
            *wp = 0;                        /* nul-terminate at new end  */
        }
    }
    return r;
}

int main (void) {

    char str[] = "                      hello world\n !",
        result[sizeof str];
    printf ("%s\n", strtrimws (result, str));
    return 0;
}

Example Use/Output

$ ./bin/trimws
hello world!

Look things over and let me know if you have any further questions. If not, good luck with your coding.