Comment supprimer le caractère à un index donné d’une chaîne dans C?

Comment supprimer un personnage d’une chaîne?

Si j’ai la chaîne "abcdef" et que je veux supprimer "b" comment puis-je le faire?

La suppression du premier caractère est facile avec ce code:

 #include  #include  #include  int main() { char word[] = "abcdef"; char word2[10]; strcpy(word2,&word[1]); printf("%s\n", word2); return 0; } 

et

 strncpy(word2,word,strlen(word)-1); 

va me donner la chaîne sans le dernier caractère, mais je n’ai toujours pas trouvé comment enlever un caractère au milieu d’une chaîne.

memmove peut gérer des zones qui se chevauchent, je voudrais essayer quelque chose comme ça (pas testé, peut-être un problème + -1)

 char word[] = "abcdef"; int idxToDel = 2; memmove(&word[idxToDel], &word[idxToDel + 1], strlen(word) - idxToDel); 

Avant: "abcdef"

Après: "abdef"

Essaye ça :

 void removeChar(char *str, char garbage) { char *src, *dst; for (src = dst = str; *src != '\0'; src++) { *dst = *src; if (*dst != garbage) dst++; } *dst = '\0'; } 

Programme de test:

 int main(void) { char* str = malloc(strlen("abcdef")+1); strcpy(str, "abcdef"); removeChar(str, 'b'); printf("%s", str); free(str); return 0; } 

Résultat:

 >>acdef 

Ma façon de supprimer tous les caractères spécifiés:

 void RemoveChars(char *s, char c) { int writer = 0, reader = 0; while (s[reader]) { if (s[reader]!=c) { s[writer++] = s[reader]; } reader++; } s[writer]=0; } 
 int chartoremove = 1; strncpy(word2,word,chartoremove); strncpy(((char*)word2)+chartoremove,((char*)word)+chartoremove+1,strlen(word)-1-chartoremove); 

Laid comme l’enfer

 char a[]="ssortingng"; int toBeRemoved=2; memmove(&a[toBeRemoved],&a[toBeRemoved+1],strlen(a)-toBeRemoved); puts(a); 

Essaye ça . memmove le chevauchera. Testé

La suite étendra un peu le problème en supprimant du premier argument de la chaîne tout caractère qui apparaît dans l’argument de la deuxième chaîne.

 /* * delete one character from a ssortingng */ static void _strdelchr( char *s, size_t i, size_t *a, size_t *b) { size_t j; if( *a == *b) *a = i - 1; else for( j = *b + 1; j < i; j++) s[++(*a)] = s[j]; *b = i; } /* * delete all occurrences of characters in search from s * returns nr. of deleted characters */ size_t strdelstr( char *s, const char *search) { size_t l = strlen(s); size_t n = strlen(search); size_t i; size_t a = 0; size_t b = 0; for( i = 0; i < l; i++) if( memchr( search, s[i], n)) _strdelchr( s, i, &a, &b); _strdelchr( s, l, &a, &b); s[++a] = '\0'; return l - a; } 

Vraiment surpris que cela n’a pas été posté avant.

 strcpy(&str[idx_to_delete], &str[idx_to_delete + 1]); 

Assez efficace et simple. strcpy utilise memmove sur la plupart des implémentations.

Ce code supprimera tous les caractères que vous entrez de la chaîne

 #include  #include  #define SIZE 1000 char *erase_c(char *p, int ch) { char *ptr; while (ptr = strchr(p, ch)) strcpy(ptr, ptr + 1); return p; } int main() { char str[SIZE]; int ch; printf("Enter a ssortingng\n"); gets(str); printf("Enter the character to delete\n"); ch = getchar(); erase_c(str, ch); puts(str); return 0; } 

consortingbution

 a man, a plan, a canal Panama 

sortie

  A mn, pln, cnl, Pnm! 

Edit: Mise à jour du code zssortingng_remove_chr() fonction de la dernière version de la bibliothèque.

A partir d’une bibliothèque de traitement de chaînes sous licence BSD pour C, appelée zSsortingng

https://github.com/fnoyanisi/zSsortingng

Fonction pour supprimer un caractère

 int zssortingng_search_chr(char *token,char s){ if (!token || s=='\0') return 0; for (;*token; token++) if (*token == s) return 1; return 0; } char *zssortingng_remove_chr(char *str,const char *bad) { char *src = str , *dst = str; /* validate input */ if (!(str && bad)) return NULL; while(*src) if(zssortingng_search_chr(bad,*src)) src++; else *dst++ = *src++; /* assign first, then incement */ *dst='\0'; return str; } 

Exemplle Usage

  char s[]="this is a sortingal ssortingng to test the function."; char *d=" ."; printf("%s\n",zssortingng_remove_chr(s,d)); 

Exemple de sortie

  thisisasortingalssortingngtotestthefunction 
 #include  #include  int main(){ char ch[15],ch1[15]; int i; gets(ch); // the original ssortingng for (i=0;i 

Supposons que x soit le "symbole" du caractère que vous voulez supprimer, mon idée était de diviser la chaîne en 2 parties:

La 1ère partie comptera tous les caractères de l'index 0 jusqu'à (et y compris) le caractère cible x.

2ème partie compte tous les caractères après x (non compris x)

Il ne vous rest plus qu'à rejoindre les deux parties.

Utilisez strcat() pour concaténer des chaînes.

Mais strcat() ne permet pas le chevauchement, vous devez donc créer une nouvelle chaîne pour contenir la sortie.

Après devrait le faire:

 #include  #include  int main (int argc, char const* argv[]) { char word[] = "abcde"; int i; int len = strlen(word); int rem = 1; /* remove rem'th char from word */ for (i = rem; i < len - 1; i++) word[i] = word[i + 1]; if(i < len) word[i] = '\0'; printf("%s\n", word); return 0; } 

J’ai essayé avec strncpy() et snprintf() .

 int ridx = 1; strncpy(word2,word,ridx); snprintf(word2+ridx,10-ridx,"%s",&word[ridx+1]); 

Une autre solution, utilisant memmove () avec index () et sizeof ():

 char buf[100] = "abcdef"; char remove = 'b'; char* c; if ((c = index(buf, remove)) != NULL) { size_t len_left = sizeof(buf) - (c+1-buf); memmove(c, c+1, len_left); } 

buf [] contient maintenant “acdef”

Cela pourrait être l’un des plus rapides, si vous passez l’index:

 void removeChar(char *str, unsigned int index) { char *src; for (src = str+index; *src != '\0'; *src = *(src+1),++src) ; *src = '\0'; } 
 #include  #include  #include  #define MAX 50 void dele_char(char s[],char ch) { int i,j; for(i=0;s[i]!='\0';i++) { if(s[i]==ch) { for(j=i;s[j]!='\0';j++) s[j]=s[j+1]; i--; } } } int main() { char s[MAX],ch; printf("Enter the ssortingng\n"); gets(s); printf("Enter The char to be deleted\n"); scanf("%c",&ch); dele_char(s,ch); printf("After Deletion:= %s\n",s); return 0; } 

C’est ce que vous recherchez peut-être alors que counter est l’index.

 #include  int main(){ char str[20]; int i,counter; gets(str); scanf("%d", &counter); for (i= counter+1; str[i]!='\0'; i++){ str[i-1]=str[i]; } str[i-1]=0; puts(str); return 0; } 

c’est comme ça que j’ai implémenté la même chose en c ++.

 #include  #include  using namespace std; int leng; char ch; ssortingng str, cpy; int main() { cout << "Enter a string: "; getline(cin, str); leng = str.length(); cout << endl << "Enter the character to delete: "; cin >> ch; for (int i=0; i 

Un moyen pratique, simple et rapide de se débarrasser de \ 0 consiste à copier la chaîne sans le dernier caractère (\ 0) à l’aide de strncpy au lieu de strcpy:

 strncpy(newStrg,oldStrg,(strlen(oldStrg)-1));