如何清除char数组中的单个字符？

Question

I'm trying to remove a single character from an array, without using the standard library functions like strcpy. how could I go about this?

I want to replace a consecutive set of spaces with a tab, and while I can replace one of the space with a tab, I don't know how to get rid of the rest of the spaces in the array. I can typecast "" into a character, and that'll remove them, but gcc throws up a warning about "cast from pointer to integer of different size". it runs fine, but the warning makes me think there's a better way of doing this. using '' doesn't work, because gcc throws the "empty character constant" error.

example code using empty character

#include <stdio.h>

int main() {
    char str[10] = "gay\n\0";
    str[1] = '';
    printf("%s", str);
}

example code using empty string, casted into char

#include <stdio.h>

int main() {
    char str[10] = "gay\n\0";
    str[1] = (char) "";
    printf("%s", str);
}

the first example throws out the error "empty character constant"

the second example works, but throws the warning "cast from pointer to integer of different size"

Answer 1

Since you are determined to do this without the benefit of standard library functions, the easiest way to accomplish replacing all series of spaces (including a series of 1) with a tab character ( '\\t' ) is to loop over your string using a variable to keep track of whether you are currently in or out of a series of spaces.

Use a simple int as a flag variable (eg int in; ) and set in = 1; (true) when you read a space, and then whenever you read something not a space set in = 0; (false) to indicate the current "state" of your read within the string (eg either in spaces or not in spaces) You then simply write a tab when you encounter the first non-space character after reading a series of spaces (eg when you change from in = 1; to in = 0; ).

As you loop over each character in the string, just keep two pointers, one to your current read-position (say p ) and one to your current write-position (say wp ). So you have a read-pointer and write-pointer. Initialize both to the beginning of your string and then advance your read-pointer every iteration either writing every character unchanged if not a space, or suppressing the write of all space character and writing a '\\t' when in changes from 1 to 0 . Seeing it helps.

You can do something like:

/** spaces2tab will convert all series of spaces in s to a '\t'.
 *  s must be mutable (writeable) and not const or a string-literal.
 */
void spaces2tab (char *s)
{
    char *p = s,    /* pointer to s -- for reading */
        *wp = s;    /* pointer to s -- for writing */
    int in = 0;     /* flag -- in/out series of spaces */

    while (*p) {                /* loop over each char in s */
        if (*p == ' ') {        /* if char is ' ' set in to 'true' */
            in = 1;
        }
        else {                  /* if other than space */
            if (in) {           /* if was series of spaces */
                *wp++ = '\t';   /* write a tab */
                in = 0;         /* set in 'false' */
            }
            *wp++ = *p;         /* write current char */
        }
        p++;                    /* advance to next char */
    }
    if (in)                     /* if was in series of spaces at end */
        *wp++ = '\t';           /* add tab at end */

    *wp = *p;                   /* nul-terminate at current char */
}

( note: the above will convert all leading spaces to a tab as well as all trailing spaces to a tab . You can modify as needed to change that behavior if you want to strip the leading and trailing spaces -- that is left to you)

Take the time to work though the logic and understand how it is working. The best way to do that is write your string to be converted out on a sheet of paper and then track were p and wp point on each iteration. (no shortcuts, don't do it on the screen, take out an 8.5x11 sheet of paper and pencil and write it out)

A full example that takes the string to convert as your first argument to your program (or uses a simple default string of " this is a test " if no argument is given) could be similar to the following (note a manual strcpy was written ( scopy ) to comport with your no library function requirement to copy characters to the string to be converted):

#include <stdio.h>

#define MAXC 128

/** spaces2tab will convert all series of spaces in s to a '\t'.
 *  s must be mutable (writeable) and not const or a string-literal.
 */
void spaces2tab (char *s)
{
    char *p = s,    /* pointer to s -- for reading */
        *wp = s;    /* pointer to s -- for writing */
    int in = 0;     /* flag -- in/out series of spaces */

    while (*p) {                /* loop over each char in s */
        if (*p == ' ') {        /* if char is ' ' set in to 'true' */
            in = 1;
        }
        else {                  /* if other than space */
            if (in) {           /* if was series of spaces */
                *wp++ = '\t';   /* write a tab */
                in = 0;         /* set in 'false' */
            }
            *wp++ = *p;         /* write current char */
        }
        p++;                    /* advance to next char */
    }
    if (in)                     /* if was in series of spaces at end */
        *wp++ = '\t';           /* add tab at end */

    *wp = *p;                   /* nul-terminate at current char */
}

char *scopy (char *dest, const char *src)
{
    char *p = dest;             /* pointer to dest */
    *dest = 0;                  /* set dest to empty-string */

    if (!src)                   /* valdiate src not NULL or return NULL */
        return NULL;

    do {                        /* loop copying chars from src to p */
        *p++ = *src;            /* (it will copy the nul-termining char) */
    } while (*src++);

    return dest;                /* return pointer to indicate success */
}

int main (int argc, char **argv) {

    char str[MAXC] = "",
        *p = argc > 1 ? argv[1] : "  this   is a      test    ";

    if (!scopy (str, p))
        return 1;

    spaces2tab (str);

    printf ("original  : '%s'\nconverted : '%s'\n", p, str);
}

Example Use/Output

$ ./bin/spaces2tab
original  : '  this   is a      test    '
converted : '   this    is      a       test    '

Verification of '\\t' Conversion

To verify the proper conversion, run your output through a hex-dump program like hexdump or od (each OS will have something similar)

$ ./bin/spaces2tab | hexdump -Cv
00000000  6f 72 69 67 69 6e 61 6c  20 20 3a 20 27 20 20 74  |original  : '  t|
00000010  68 69 73 20 20 20 69 73  20 61 20 20 20 20 20 20  |his   is a      |
00000020  74 65 73 74 20 20 20 20  27 0a 63 6f 6e 76 65 72  |test    '.conver|
00000030  74 65 64 20 3a 20 27 09  74 68 69 73 09 69 73 09  |ted : '.this.is.|
00000040  61 09 74 65 73 74 09 27  0a                       |a.test.'.|
00000049

Above you can confirm all series of spaces (hex 20 ) have been converted to a single tab character (hex 09 ).

Let me know if you have further questions.