Comment supprimer \ n ou \ t d’une chaîne donnée en C?

Comment puis-je effacer une chaîne avec tous les \ n et \ t en C?

Cela fonctionne dans mes tests rapides et sales. Est-ce en place:

#include  void ssortingp(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\na\t test\n test"; ssortingp(buf); printf("%s\n", buf); } 

Et pour apaiser Chris, voici une version qui en fera une copie d’abord et la renverra (ainsi, cela fonctionnera littéralement). Vous devrez free le résultat.

 char *ssortingp_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; } 

Si vous voulez remplacer \ n ou \ t par quelque chose d’autre , vous pouvez utiliser la fonction strstr (). Il renvoie un pointeur à la première place d’une fonction comportant une certaine chaîne. Par exemple:

 // Find the first "\n". char new_char = 't'; char* pFirstN = strstr(szMySsortingng, "\n"); *pFirstN = new_char; 

Vous pouvez exécuter cela en boucle pour trouver tous les \ n et les \ t.

Si vous voulez les “rayer”, c’est-à-dire les supprimer de la chaîne , vous devrez utiliser la même méthode que ci-dessus, mais copiez le contenu de la chaîne “back” à chaque fois que vous trouvez un \ n ou \ t, de sorte que “ceci est un test” devient: “ceci est un test”.

Vous pouvez le faire avec memmove (pas memcpy, puisque src et dst pointent vers une mémoire superposée), comme ceci:

 char* temp = strstr(str, "\t"); // Remove \n. while ((temp = strstr(str, "\n")) != NULL) { // Len is the length of the ssortingng, from the ampersand \n, including the \n. int len = strlen(str); memmove(temp, temp + 1, len); } 

Vous devrez répéter cette boucle pour enlever les \ t’s.

Remarque: ces deux méthodes fonctionnent sur place. Cela pourrait ne pas être sûr! (Lisez les commentaires de Evan Teran pour plus de détails. De plus, ces méthodes ne sont pas très efficaces, bien qu’elles utilisent une fonction de bibliothèque pour une partie du code au lieu de faire tourner le vôtre.

En gros, vous avez deux façons de procéder: vous pouvez créer une copie de la chaîne d’origine, moins tous les caractères '\t' et '\n' , ou vous pouvez supprimer la chaîne “sur place”. Cependant, je parie que la première option sera plus rapide, et je vous promets que ce sera plus sûr.

Nous allons donc créer une fonction:

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

Nous voulons utiliser strlen() et malloc() pour allouer un nouveau tampon char * de la même taille que notre tampon str . Ensuite, nous str caractère par caractère. Si le caractère n’est pas contenu dans d , nous le copions dans notre nouveau tampon. Nous pouvons utiliser quelque chose comme strchr() pour voir si chaque caractère est dans la chaîne d . Une fois que nous avons terminé, nous avons un nouveau tampon, avec le contenu de notre ancien tampon moins de caractères dans la chaîne d , nous le renvoyons donc. Je ne vous donnerai pas d’exemple de code, car cela pourrait être un devoir, mais voici un exemple d’utilisation pour vous montrer comment il résout votre problème:

 char *ssortingng = "some\n text\t to ssortingp"; char *ssortingpped = ssortingp(ssortingng, "\t\n"); 

C’est une fonction de chaîne ac qui recherchera n’importe quel caractère dans accept et retournera un pointeur sur cette position ou NULL s’il n’est pas trouvé.

 #include  char *strpbrk(const char *s, const char *accept); 

Exemple:

 char search[] = "a ssortingng with \t and \n"; char *first_occ = strpbrk( search, "\t\n" ); 

first_occ va pointer sur le \ t, ou le 15 caractère de la search . Vous pouvez remplacer puis rappeler pour passer en boucle jusqu’à ce que tous aient été remplacés.

J’aime faire en sorte que la bibliothèque standard effectue le plus de travail possible. J’utiliserais donc quelque chose de similaire à la solution d’Evan, mais avec strspn() et strcspn() .

 #include  #include  #include  #define SPACE " \t\r\n" static void ssortingp(char *s); static char *ssortingp_copy(char const *s); int main(int ac, char **av) { char s[] = "this\t is\na\t test\n test"; char *s1 = ssortingp_copy(s); ssortingp(s); printf("%s\n%s\n", s, s1); return 0; } static void ssortingp(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 *ssortingp_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; }