web-dev-qa-db-fra.com

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

Comment supprimer un caractère d'une chaîne? 

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

Supprimer le caractère premier est facile avec ce code:

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

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);

me donnera la chaîne sans le caractère last , mais je n’ai toujours pas compris comment supprimer un caractère dans le milieu d’une chaîne.

cstring
43
Favolas

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

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

Avant: "abcdef"

Après: "abdef"

56
stacker

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
36
Fabio Cabral

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;
}
9
tBlabs
char a[]="string";
int toBeRemoved=2;
memmove(&a[toBeRemoved],&a[toBeRemoved+1],strlen(a)-toBeRemoved);
puts(a);

Essaye ça . memmove le chevauchera . Testé.

4
SaravananKS
int chartoremove = 1;
strncpy(Word2,Word,chartoremove);
strncpy(((char*)Word2)+chartoremove,((char*)Word)+chartoremove+1,strlen(Word)-1-chartoremove);

Moche comme l'enfer

4
ssteinberg

Vraiment surpris, cela n'a pas été posté auparavant.

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

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

3
MD XF

Ce qui suit étend le problème un peu en supprimant du premier argument de chaîne tout caractère figurant dans le second argument de chaîne.

/*
 * delete one character from a string
 */
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;
}
2
Dan the Man
#include <stdio.h>
#include <string.h>

int main(){
    char ch[15],ch1[15];
    int i;
    gets(ch);  // the original string
    for (i=0;i<strlen(ch);i++){  
        while (ch[i]==ch[i+1]){ 
            strncpy(ch1,ch,i+1); //ch1 contains all the characters up to and including x
            ch1[i]='\0'; //removing x from ch1
            strcpy(ch,&ch[i+1]);  //(shrinking ch) removing all the characters up to and including x from ch
            strcat(ch1,ch); //rejoining both parts
            strcpy(ch,ch1); //just wanna stay classy
        }
    }
    puts(ch);
}

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

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

La 2e partie contient tous les caractères après x (x non compris)

Maintenant, tout ce que vous avez à faire est de rejoindre les deux parties.

1
Wassim Mohsni

Edit: Mise à jour du code zstring_remove_chr() en 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 zString

https://github.com/fnoyanisi/zString

Fonction pour supprimer un personnage

int zstring_search_chr(char *token,char s){
    if (!token || s=='\0')
        return 0;

    for (;*token; token++)
        if (*token == s)
            return 1;

    return 0;
}

char *zstring_remove_chr(char *str,const char *bad) {
    char *src = str , *dst = str;

    /* validate input */
    if (!(str && bad))
        return NULL;

    while(*src)
        if(zstring_search_chr(bad,*src))
            src++;
        else
            *dst++ = *src++;  /* assign first, then incement */

    *dst='\0';
    return str;
}

Exemple d'utilisation

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

Exemple de sortie

  thisisatrialstringtotestthefunction
1
Fehmi Noyan ISI

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

#include <stdio.h>
#include <string.h>

#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 string\n");
    gets(str);
    printf("Enter the character to delete\n");
    ch = getchar();

    erase_c(str, ch);

    puts(str);

    return 0;
}

contribution 

a man, a plan, a canal Panama

sortie

 A mn,  pln,  cnl, Pnm!
1
Orkun Tokdemir

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

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

0
David Heffernan

Après devrait le faire:

#include <stdio.h>
#include <string.h>
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;
}
0
Rumple Stiltskin

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

int ridx = 1;  
strncpy(Word2,Word,ridx);   
snprintf(Word2+ridx,10-ridx,"%s",&Word[ridx+1]);
0
Prince John Wesley

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

#include <stdio.h>

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;
}
0
iDream
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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 string\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;
}
0
Mushrif Ali

Une autre solution, en 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"

0
presto8

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';
}
0
Özgür