Chaîne de filtre dans C

Question

Comment puis-je filtrer une chaîne dans c? Je veux enlever tout ce qui n'est pas [a-z0-9_].

int main(int argc, char ** argv) { 
    char* name = argv[1]; 
    // remove anything that isn't [a-z0-9_] 

    printf("%s", name); 
} 

Answer 1

char *src, *dst; 
for (src = name, dst = name; *src; src++) { 
    if ('a' <= *src && *src <= 'z' 
    || '0' <= *src && *src <= '9' 
    || *src == '_') *dst++ = *src; 
} 
*dst = '\0'; 

EDIT: Plusieurs petites révisions. J'espère avoir les bugs maintenant.

Answer 2

La bibliothèque standard C ne fournit aucun support pour les expressions régulières.
Vous devrez soit télécharger une bibliothèque RegEx en C (une très courante est PCRE), ou le faire en boucle (plus facile dans le cas présent, puisque les expressions recherchées sont toutes des caractères uniques, donc pas de retour en arrière) .

L'approche en boucle ressemblerait à quelque chose comme:

int main(int argc, char ** argv) { 
    char* name = argv[1]; 

    // remove anything that isn't [a-z0-9_] 
    char strippedName[200]; 
    int iIn, iOut; // subscript in Name and StrippedName respectively 

    iIn = iOut = 0; 
    while (name[iIn] != '\0' && iOut < (sizeof(strippedName) + 1)) { 
     // some condition defining a desirable character 
     // BTW, this condition should actually be 
     // if (islower(name[iIn]) || isdigit(name[iIn] || name[iIn] == '_') 
     // to match the OP's requirement exactly 
     if (isalnum(name[iIn]) || name[iIn] == '_') 
     strippedName[iOut++] = name[iIn]; 
     iIn++; 
    } 
    strippedName[iOut++] = '\0'; 

    printf("%s", strippedName); 
} 

D'autres expressions régulières dans la langue C (autre que PCRE mentionné plus haut):

• TRE
• Henry Spencer's regex

Answer 3

Jetez un oeil à isalphanum

Answer 4

Consultez ctype pour les fonctions permettant de tester chaque caractère dans une boucle.

Answer 5

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

int main(int argc, char ** argv) 
{  
    char *name, *inp, *outp; 

    if (argc < 2) 
    { 
     fprintf(stderr, "Insufficient arguments.\n"); 
     return 1; 
    } 

    inp = argv[1]; 
    name = malloc(strlen(inp) + 1); 
    outp = name; 

    if (!name) 
    { 
     fprintf(stderr, "Out of memory.\n"); 
     return 2; 
    } 

    while (*inp) 
    { 
     if (islower((unsigned char)*inp) || isdigit((unsigned char)*inp) || *inp == '_') 
      *outp++ = *inp; 
     inp++; 
    } 

    *outp = '\0'; 

    puts(name); 
    free(name); 

    return 0; 
} 

Answer 6

Si vous voulez juste enlever les caractères indésirables de premier argument, il n'y a pas besoin d'allocation de mémoire, juste marcher à travers le caractère par caractère chaîne d'entrée. Et, si vous savez que vous travaillerez dans un environnement ASCII (ou n'importe quel autre supportant a à z), vous pouvez même remplacer les appels de fonction par des versions plus rapides en vérifiant les plages de caractères. Mais, je ne vois pas l'augmentation de la vitesse comme suffisante pour justifier le code non portable.

#include <stdio.h> 
#include <string.h> 
#include <ctype.h> 
int main(int argc, char ** argv) { 
    int i; 
    char *p; 
    if (argc > 1) { 
     for (p = argv[1]; *p != '\0'; p++) { 
      if (islower(*p) || isdigit(*p) || *p == '_') { 
       putchar (*p); 
      } 
     } 
     putchar ('\n'); 
    } 
    return 0; 
}