Les chaînes en c, ltrim, rtrim, replace et reverse

Télécharger le projet
Commenter

Description

Quelques fonctions de manipulations de chaînes et une explication
(les commentaires sont dans le zip, je ne poste que le code).
Des exemples d'utilisation (le mai) est dans le zip.
Les premières fonctions sont fournies en standard en C.
J'ai les ai mises par ordre de difficulté (à mon avis, il faut les comprendre
dans l'ordre)
Voici mes choix d'implémentation (qui sont facilement modifiables selon
vos besoins ) :
1. les fonctions modifies la chaîne entrante
2. les trims acceptent une chaînes contenant les caractères à supprimer.
3. les trims auraient pu utiliser la fonction find, j'ai préféré une table locale.
(c'est discutable et j'ai hésité)

Source / Exemple : 


int length( const char* s ) {
    const char* org = s;
    while( *s )
        ++s;
    return ( s - org );
}

const char* find( const char* str, char c ) {
    while( *str ) {
        if ( *str == c ) return str;
        ++str;
    }
    return 0;
}

char* copy( char* dst, const char* src ) {
    char* cur = dst;
    while( *cur++ = *src++ )
        ;
    return dst;
}

char* rtrim( char* str, const char* t )
{
    char* curEnd = str, *end = str;

    char look[ 256 ] = {  1, 0 };
    while( *t )
       look[ (unsigned char)*t++ ] = 1;

    while( *end ) {
      if ( !look[ *end ] )
          curEnd = end + 1;
      ++end;
    }


        
  • curEnd = '\0';


    return str;
}

char* ltrim( char* str, const char* t ) {
    char* curStr = NULL;

    char look[ 256 ] = { 1, 0 };
    while( *t )
        look[ (unsigned char)*t++ ] = 1;

    curStr = str;
    while( *curStr && look[ *curStr ] )
        ++curStr;

    return copy( str, curStr );
}

char* trim( char* str, const char* t ) {
    return ltrim( rtrim( str, t ), t );
}

char* replace( char* str, const char* r, const char* b ) {
    char* curDst = NULL;

    char look[ 256 ] = { 0 };
    while( *r && *b )
        look[ (unsigned char)*r++ ] = *b++;

    curDst = str;
    while( *curDst ) {
        char c = look[ *curDst ];
        if ( c ) *curDst = c;
        ++curDst;
    }
    return str;
}

char* reverse( char* str ) {
    char* right = str, *left = NULL;
    while( *right )
        ++right;

    left = str;
    while(  left < right )  {
        char tmp = *left;


            
  • left++ = *--right;

    •         
  • right = tmp;

    }
    return str;
}

Conclusion :


J'ai pas eu encore le courage de faire mon 3ième tuto sur les C++.
Comme j'ai rien trouvé de bien répondant à ces questions, je poste ça.
C'est court mais de toute façon, quand c'est long les gens ne lisent pas ;-)
le rtrim a été légèrement modifiée.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Hylvenir)