Comment faire pour supprimer \n ou \t à partir d'une chaîne de caractères en C?

Cela fonctionne dans ma rapide et sale tests. Est-il en place:

#include <stdio.h>

void strip(char *s) {
    char *p2 = s;
    while(*s != '
#include <stdio.h>
void strip(char *s) {
char *p2 = s;
while(*s != '\0') {
if(*s != '\t' && *s != '\n') {
*p2++ = *s++;
} else {
++s;
}
}
*p2 = '\0';
}
int main() {
char buf[] = "this\t is\n a\t test\n test";
strip(buf);
printf("%s\n", buf);
}
') {
        if(*s != '\t' && *s != '\n') {
            *p2++ = *s++;
        } else {
            ++s;
        }
    }
    *p2 = '
#include <stdio.h>
void strip(char *s) {
char *p2 = s;
while(*s != '\0') {
if(*s != '\t' && *s != '\n') {
*p2++ = *s++;
} else {
++s;
}
}
*p2 = '\0';
}
int main() {
char buf[] = "this\t is\n a\t test\n test";
strip(buf);
printf("%s\n", buf);
}
';
}

int main() {
    char buf[] = "this\t is\n a\t test\n test";
    strip(buf);
    printf("%s\n", buf);
}

Et pour l'apaiser, Chris, voici une version qui va faire une copie de la première et de la retourner (donc il va travailler sur les littéraux). Vous aurez besoin de free le résultat.

char *strip_copy(const char *s) {
    char *p = malloc(strlen(s) + 1);
    if(p) {
        char *p2 = p;
        while(*s != '
char *strip_copy(const char *s) {
char *p = malloc(strlen(s) + 1);
if(p) {
char *p2 = p;
while(*s != '\0') {
if(*s != '\t' && *s != '\n') {
*p2++ = *s++;
} else {
++s;
}
}
*p2 = '\0';
}
return p;
}
') {
            if(*s != '\t' && *s != '\n') {
                *p2++ = *s++;
            } else {
                ++s;
            }
        }
        *p2 = '
char *strip_copy(const char *s) {
char *p = malloc(strlen(s) + 1);
if(p) {
char *p2 = p;
while(*s != '\0') {
if(*s != '\t' && *s != '\n') {
*p2++ = *s++;
} else {
++s;
}
}
*p2 = '\0';
}
return p;
}
';
    }
    return p;
}

OriginalL'auteur Evan Teran

En gros, vous avez deux façons de le faire: vous pouvez créer une copie de la chaîne d'origine, moins tous les '\t' et '\n' caractères, ou vous pouvez enlever la chaîne "en place". Cependant, je parie que la première option sera plus rapide, et je vous promets qu'il sera plus en sécurité.

Nous allons donc faire une fonction:

char *strip(const char *str, const char *d);

Nous voulons utiliser strlen() et malloc() pour allouer un nouveau char * tampon de la même taille que notre str tampon. Puis nous passons par str caractère par caractère. Si le personnage est pas contenues dans d, on le copie dans notre nouveau tampon. Nous pouvons utiliser quelque chose comme strchr() pour voir si chaque caractère dans la chaîne d. Une fois que nous aurons terminé, nous avons un nouveau tampon, avec le contenu de nos vieux tampon de moins de caractères dans la chaîne d, donc nous avons juste retour que. Je ne vais pas vous donner un exemple de code, parce que cela pourrait être des devoirs, mais ici, c'est l'exemple de l'utilisation pour vous montrer comment résoudre votre problème:

char *string = "some\n text\t to strip";

char *stripped = strip(string, "\t\n");

OriginalL'auteur Chris Lutz

J'aime faire de la bibliothèque standard de faire autant de travail que possible, donc je voudrais l'utiliser quelque chose de similaire à Evan solution mais avec strspn() et strcspn().

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SPACE " \t\r\n"
static void strip(char *s);
static char *strip_copy(char const *s);
int main(int ac, char **av)
{
char s[] = "this\t is\n a\t test\n test";
char *s1 = strip_copy(s);
strip(s);
printf("%s\n%s\n", s, s1);
return 0;
}
static void strip(char *s)
{
char *p = s;
int n;
while (*s)
{
n = strcspn(s, SPACE);
strncpy(p, s, n);
p += n;
s += n + strspn(s+n, SPACE);
}
*p = 0;
}
static char *strip_copy(char const *s)
{
char *buf = malloc(1 + strlen(s));
if (buf)
{
char *p = buf;
char const *q;
int n;
for (q = s; *q; q += n + strspn(q+n, SPACE))
{
n = strcspn(q, SPACE);
strncpy(p, q, n);
p += n;
}
*p++ = '\0';
buf = realloc(buf, p - buf);
}
return buf;
}

OriginalL'auteur finnw