begin process at 2012 02 10 13:24:03
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > 

Code

 > 

Tutoriaux

 > LES CHAÎNES EN C, LTRIM, RTRIM, REPLACE ET REVERSE

LES CHAÎNES EN C, LTRIM, RTRIM, REPLACE ET REVERSE


 Information sur la source

Note :
7 / 10 - par 1 personne
7,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Tutoriaux Niveau :Débutant Date de création :24/04/2004 Date de mise à jour :25/04/2004 19:11:54 Vu / téléchargé :5 062 / 187
Auteur : Hylvenir

Ecrire un message privé
Site perso
Commentaire sur cette source (17)
Ajouter un commentaire et/ou une note

 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

  • 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;
  • } 
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.

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip Source avec une capture SUDOKU HELPER
Source avec Zip Source avec une capture EPONGE DE SIERPINSKI-MENGER
Source avec Zip Source avec une capture FLOCON DE VON KOCH
FONCTION EXPLODE (OU SPLIT)
Source avec Zip Source avec une capture LECTURE ASE / SDL / OPENGL
Toutes les sources de Hylvenir

 Sources de la même categorie

LISTER FICHIERS ET RÉPERTOIRES (MULTIPLATEFORME) par christophedlr
UTILISATION DES TYPELIST EN C++ par wyden
Source avec Zip Source avec une capture QCSSCOMPRESSOR par alphaone
AFFICHAGE D'UN TRIANGLE ISOCELE par nabche
Source avec Zip GESTION D'UNE BIBLOTHEQUE par leclerro19
Toutes les sources de la catégorie Tutoriaux

Commentaires et avis

Commentaire de BruNews le 25/04/2004 00:10:31 administrateur CS

Salut,

je te soumets une reflexion:
a quoi sert de retourner dans 'copy' par exemple le pointeur qu'on lui fournit , quel interet puisqu'on l'a deja ? Ne serait pas mieux de retourner pointeur sur FIN de copie afin d'eviter d'eventuels strcat. Le benef de performance dans du reporting (exemple) est considerable, les chaines ne sont parcourues qu'une seule fois. C'est pour ma part ce que j'ai toujours reproche a strcpy.
Qu'en penses-tu ?

BruNews

Commentaire de Hylvenir le 25/04/2004 20:50:12

Si on considére la chaîne C (char*) comme un objet, on peut considérer le strpcy, ou le strcat comme des fonctions membres, (au même titre que l'opérateur = ou += pour les std::string ).
Les concepteurs ont sûrement voulu faire en sorte qu'un utilisateur retrouvre sa chaîne d'origine en sortie afin de pouvoir utiliser cette chaîne. Comme ça "l'objet" chaîne ne varie pas du point de vue de l'utilisateur, on peut ainsi enchaîner des appels constructeurs/modifications sur le même objet chaîne.

Je n'ai jamais mesuré la pénalité du parcours en fin de chaine lors d'un strcat, comparé par exemple à simple formatage d'un entier dans une chaîne (assez fréquent ).
Dans le cas de concaténation successive, la gestion de la taille de la chaîne devrait poser plus de problème que la concaténation. A voir.
Mais pourquoi pas en effet voir ce que cela donne à l'usage d'avoir un retour sur fin de chaîne.

Commentaire de djl le 25/04/2004 23:28:06

juste pour le fun,

un strlen (length) ecrit dans le style k&r

strlen(s)
char s[];
{
    register i=0;
    while(*(++i+s)!=0);
    return i;
}

un  find

find(str,c)
char str[];
int c;
{
    register i;
    for(i=0; i[str]!=c; i++);
    return i;
}

un strcpy

char *strcpy(dest,src)
char dest[];
char src[];
{
    register i=0;
    while(dest[i++]=src[i]);
    return dest;
}

100% compatible c asni

Commentaire de Hylvenir le 26/04/2004 00:09:23

y'a pas a dire c'est moche le K&R ;-)

Commentaire de djl le 26/04/2004 00:22:42

oui, surtout pour les passage de parametre, et la regle du int par defaut n'aide pas a la lisibilite si on est pas habituer

qq truc aussi:

register i; = register int i; // int type par defaut

on passe int c au lieu de char c car les char sont promus en int lorsqu'ils sont passer en parametre (de meme pour les short, les float sont promus en double)

pas de const

Commentaire de NeoUmbrella le 09/06/2005 22:37:41

Dommage que ca ne marche pas véritablement comme la fonction en vb car on ne peut pas utiliser des constantes style reverse("test")

Commentaire de BruNews le 09/06/2005 22:44:10 administrateur CS

Ah mais non ce n'est pas dommage, c'est juste qu'en C on le code mais qu'en VB c'est caché dans une virtual machine. VB te ferait un SysAllocString et recopié "test" dedans avant d'y inverser les octets, voila ce que tu n'aurais pas vu mais aurait couté très cher en cycles processeur.

Commentaire de NeoUmbrella le 09/06/2005 23:40:44

Ha oais ok ^^, j'ai rien dit dans ce cas Hylvenir.

Commentaire de Hylvenir le 10/06/2005 00:01:51

:) No problemo.

Il faut juste savoir ce qu'il t'en coûte d'utiliser telle ou telle méthode. Elles ont toutes des avantages et des inconvénients. Il faut faire des choix.

Commentaire de sebastienmz le 08/11/2006 17:11:27

comment marche replace?

Commentaire de lillith212 le 23/05/2008 15:35:52 7/10

Merci pour ce code, Il m'a permit de comprendre certaines choses, cependant, ce que je regrette, c'est en tant que tr?s grande d?butante, je n'ai trouv? aucun commentaire...
Bonne continuation
Bonne prog

Commentaire de sheorogath le 23/05/2008 17:20:08 administrateur CS

strlen(s)
char s[];
{
    register i=0;
    while(*(++i+s)!=0);
    return i;
}

==> heuuuuu en lisant le code si ta chaine est egale a "" tu retournes 1
faudrais faire partir i a -1 non ? ou j'ai loupe un episode ?

Commentaire de BruNews le 24/05/2008 09:46:22 administrateur CS

DWORD bnstrlen(char *s)
{
  char *c = s;
  while(*c) c++;
  return (c - s);
}

Commentaire de Hylvenir le 24/05/2008 12:13:25

4 ans.. ça fait un bail...
Tiens, BruNews, avec le recul (4 ans), la première remarque sur le strcopy était intéressante puisque finalement, j'ai bien fini par ajouté une fonction appender qui renvoit la fin de la chaine. comme quoi.

DWORD... toujours sous windows donc. (size_t serait bien le bienvenue ici, de même qu'un const char*)

Commentaire de BruNews le 24/05/2008 13:37:59 administrateur CS

eh oui, je reste où sont les clients, faut bien payer les frais et le superflu.
C'est chouette quand il y a un rappel sur ces vieilles sources, un gout de nostalgie.
Bonne continuation.

Commentaire de sheorogath le 24/05/2008 14:15:05 administrateur CS

:d

puis bon pour toi etre sous linux correspond a etre communiste ^^

Commentaire de Hylvenir le 24/05/2008 15:14:18

De mon côté, je suis passé de hpux sous Linux, Windows et Sun.
alors je dois juste éviter les problèmes de portabilité.

Les clients, faut savoir les choisir ;)

Bonne continuation aussi.

 Ajouter un commentaire

Nos sponsors


Sondage...

Comparez les prix


Acer Liquid (noir) (XP.H480Q.013)
Entre 300€ et 346€

Visiter le guide achat

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

Photo Beautiful woman in a bikini meditating on the beachPhoto Single Large Rock Formation in Monument Valley
Photo Water in the Beginning of the Grand Canyon 

Visiter la photothèque
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,045 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib (Android Market)