begin process at 2013 05 18 21:27:44
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Chaîne de caractères

 > CLASSE CSTRING : GESTION DE CHAINES DE CARACTÈRES EN C++

CLASSE CSTRING : GESTION DE CHAINES DE CARACTÈRES EN C++


 Information sur la source

Note :
Aucune note
Catégorie :Chaîne de caractères Niveau :Débutant Date de création :23/08/2004 Date de mise à jour :13/09/2004 08:24:24 Vu / téléchargé :35 260 / 932

Auteur : Soilwork9

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

 Description

Voila, encore une classe de plus permettant de gérer les chaines de caractères.. ;)
En fait j'ai décidé de me remettre dans le bain C++ après une cure de Java, et je suppose que le meilleur moyen de reprendre l'utilisation des pointeurs, c'est de jouer avec des chaines de caractère, donc c'est ce que j'ai fait ^_^

Source

  • #ifndef CSTRING_H_INCLUDED
  • #define CSTRING_H_INCLUDED
  • #include <stdio.h>
  • #include <string.h>
  • //Longueur maximale utilisee pour les chaines temporaires utilisees dans
  • //certaines methodes de la classe.
  • //Les chaines 'normales' peuvent etre plus longues.
  • #define MAX_LG 1024
  • class CString
  • {
  • private:
  • char *ptr;
  • //Longueur de la chaine
  • unsigned int len;
  • //Indice de debut du prochain token
  • unsigned int tokenIndex; //Pour decouper la chaine en tokens...
  • inline void reallocation(int lg);
  • public:
  • ///////////////////
  • // Constructeurs //
  • ///////////////////
  • //Constructeur par défaut
  • CString(){ptr=new char[1];ptr[0]=0; tokenIndex=0; len=0;};
  • //Constructeur par recopie
  • CString(const CString& string);
  • //Constructeur à partir d'une chaîne de caracteres (char *)
  • CString(const char *pointer);
  • //Constructeurs à partir de nombres entiers/flottants/doubles
  • CString(int number);
  • CString(float number);
  • CString(double number);
  • //A partir d'un caractère
  • CString(char character);
  • //A partir d'un booleen ==> Contient true ou false.
  • CString(bool boolean);
  • //Construction d'une chaine contenant n fois le caractere character
  • CString(int n, char character);
  • //Destructeur!
  • ~CString(){ if(ptr) delete[]ptr;};
  • ////////////////
  • // Accesseurs //
  • ////////////////
  • void setPtr(const char *pointer) {(*this)=pointer;};
  • char * getPtr() const {return ptr;};
  • //Désactivé à cause de l'opérateur de cast en char * ==> Ambiguite!
  • //char operator[](unsigned int index) const;
  • //Retourne le caractère à l'indice donné, -1 en cas de mauvais indice
  • //(Equivalent a l'operateur [])
  • char charAt(unsigned int index) const;
  • //Longueur de la chaine
  • int length() const {return len;}; //{return strlen(ptr);};
  • //Operateurs de conversion
  • operator const char*() const {return (const char *)ptr;};
  • //Est-ce que la chaine est vide?
  • bool isEmpty() const {return(length()==0?true:false);};
  • //////////////////////////////
  • // Operateurs d'affectation //
  • //////////////////////////////
  • //Ces operateurs retournent une reference sur la chaine elle-meme.
  • CString &operator=(const CString& string);
  • CString &operator=(const char *pointer);
  • CString &operator=(int number);
  • CString &operator=(float number);
  • CString &operator=(double number);
  • CString &operator=(char character);
  • CString &operator=(bool boolean);
  • //Méthodes d'affectation
  • CString &assign(CString string);
  • CString &assign(int n, char character);
  • //Lecture d'une ligne au clavier...
  • CString &getLine();
  • //Nettoyage de la chaine... (retour a une chaine vide)
  • CString &clear();
  • ///////////////////////////////
  • // Operateurs de comparaison //
  • ///////////////////////////////
  • //Methodes de comparaison QUI PRENNENT EN COMPTE LA CASSE
  • //(majuscule/minuscule)
  • bool operator==(const CString& string) const;
  • bool operator!=(const CString& string) const;
  • bool operator<(const CString& string) const;
  • bool operator<=(const CString& string) const;
  • bool operator>(const CString& string) const;
  • bool operator>=(const CString& string) const;
  • //Methode de comparaison identique a ==
  • bool equals(const CString& string) const;
  • //Equals qui ignore la casse
  • bool equalsIgnoreCase(const CString& string) const;
  • /////////////////////////////////
  • // Opérateurs de concatenation //
  • /////////////////////////////////
  • CString &operator+=(const CString& string);
  • //Pour pouvoir ajouter tout et n'importe quoi :)
  • friend CString operator+(CString first, CString second);
  • //Methodes de concatenation...
  • CString &append(CString string);
  • CString &append(int n, char character);
  • //Et aussi d'insertion...
  • CString &insertAt(int index, CString string);
  • //////////////////////
  • // Autres fonctions //
  • //////////////////////
  • //Est-ce que la chaine commence par prefix?
  • bool startsWith(CString prefix) const;
  • //Est-ce que la chaine se termine par suffix?
  • bool endsWith(CString suffix) const;
  • //Est-ce que la région de la chaine commencant a l'indice toffset
  • //et de longueur len est identique à la region de other commencant
  • //a ooffset et de meme longueur len (avec ou sans gestion de la casse)
  • bool regionMatches(int toffset, CString other, int ooffset, int len,
  • bool ignoreCase=false) const;
  • //Extraction de sous-chaine commencant a l'indice index jusqu'a la fin
  • CString substring(int index) const;
  • //Idem, mais sous-chaine de longueur length
  • CString substring(int index, int length) const;
  • //Indice de la premiere occurence de substring dans la chaine
  • //-1 si non trouvé
  • int indexOf(CString substring) const;
  • //Idem, mais pour la derniere occurence de substring
  • int lastIndexOf(CString substring) const;
  • //Retourne la chaine || eniahc al enruoter // :P
  • CString &reverse();
  • //Fonction inutile pour savoir si une chaine est un palindrome ^_^
  • bool isPalindrome() const;
  • //Remplace toutes les occurences de string par byString
  • //Retourne le nombre de changements effectues
  • int replace(CString string, CString byString);
  • //Remplace uniquement le premier
  • int replaceFirst(CString string, CString byString);
  • //Uniquement le dernier
  • int replaceLast(CString string, CString byString);
  • //Remplace la sous-chaine de longueur lg1 commencant a l'indice index
  • //par byString.
  • int replaceAt(int index, int lg1, CString byString);
  • //Pour changer la casse de la chaine...
  • CString &toLowerCase(); //En minuscules
  • CString &toUpperCase(); //En majuscules
  • //Premiere lettre de chaque mot en majuscules, le reste en minuscules.
  • //Les mots sont séparés par tout caractere non-alphabétique.
  • CString &capitalize();
  • //Fonction "a la printf"
  • CString &format(char *formatString, ...);
  • //Redimensionne la chaine, en ajoutant character a la fin si necessaire
  • //(len n'inclut pas l'\0 final!)
  • CString &resize(int len, char character=' ');
  • //Suppression d'espaces superflus
  • CString &ltrim();
  • CString &rtrim();
  • CString &trim(); //Des deux cotes
  • //Fonction de hachage facon java.lang.String (cf Java API)
  • unsigned long long int hashCode() const;
  • //Decoupage de la chaine...
  • //retourne un pointeur vers des chaines et
  • //le nombre de morceaux dans la variable par reference outNumber.
  • CString *split(int &outNumber, char character) const;
  • //Tokenisation : Les tokens sont separes par des espaces
  • //OU compris entre simple ou double quotes.
  • int countToken() const;
  • void resetToken(){tokenIndex=0;};
  • CString nextToken();
  • CString endOfString() const;
  • };
  • #endif
#ifndef CSTRING_H_INCLUDED
#define CSTRING_H_INCLUDED

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


//Longueur maximale utilisee pour les chaines temporaires utilisees dans  
//certaines methodes de la classe. 
//Les chaines 'normales' peuvent etre plus longues.
#define MAX_LG 1024

class CString
{
private:
    char *ptr;
    
    //Longueur de la chaine
    unsigned int len;
    
    //Indice de debut du prochain token
    unsigned int tokenIndex; //Pour decouper la chaine en tokens...
    
    inline void reallocation(int lg);
public:
    ///////////////////        
    // Constructeurs //
    ///////////////////
    
    //Constructeur par défaut
    CString(){ptr=new char[1];ptr[0]=0; tokenIndex=0; len=0;};
    //Constructeur par recopie
    CString(const CString& string);
    //Constructeur à partir d'une chaîne de caracteres (char *)
    CString(const char *pointer);
    //Constructeurs à partir de nombres entiers/flottants/doubles
    CString(int number);
    CString(float number);
    CString(double number);
    //A partir d'un caractère
    CString(char character);
    //A partir d'un booleen ==> Contient true ou false.
    CString(bool boolean);
    //Construction d'une chaine contenant n fois le caractere character
    CString(int n, char character);
    
    //Destructeur!
    ~CString(){ if(ptr) delete[]ptr;};
    
    ////////////////
    // Accesseurs //
    ////////////////
    void setPtr(const char *pointer) {(*this)=pointer;};
    char * getPtr() const {return ptr;};
    
    //Désactivé à cause de l'opérateur de cast en char * ==> Ambiguite!
    //char operator[](unsigned int index) const;
    
    //Retourne le caractère à l'indice donné, -1 en cas de mauvais indice
    //(Equivalent a l'operateur [])
    char charAt(unsigned int index) const;
    
    //Longueur de la chaine
    int length() const {return len;}; //{return strlen(ptr);};
    
    //Operateurs de conversion
    operator const char*() const {return (const char *)ptr;};
    //Est-ce que la chaine est vide?
    bool isEmpty() const {return(length()==0?true:false);};
    
    //////////////////////////////
    // Operateurs d'affectation //
    //////////////////////////////
    //Ces operateurs retournent une reference sur la chaine elle-meme.
    CString &operator=(const CString& string);
    CString &operator=(const char *pointer);
    CString &operator=(int number);
    CString &operator=(float number);
    CString &operator=(double number);
    CString &operator=(char character);
    CString &operator=(bool boolean);
    
    //Méthodes d'affectation
    CString &assign(CString string);
    CString &assign(int n, char character);
    
    //Lecture d'une ligne au clavier...
    CString &getLine();
    
    //Nettoyage de la chaine... (retour a une chaine vide)
    CString &clear();
    
    ///////////////////////////////
    // Operateurs de comparaison //
    ///////////////////////////////
    //Methodes de comparaison QUI PRENNENT EN COMPTE LA CASSE
    //(majuscule/minuscule)
    bool operator==(const CString& string) const;
    bool operator!=(const CString& string) const;
    bool operator<(const CString& string) const;
    bool operator<=(const CString& string) const;
    bool operator>(const CString& string) const;
    bool operator>=(const CString& string) const;
    
    //Methode de comparaison identique a ==
    bool equals(const CString& string) const;
    
    //Equals qui ignore la casse
    bool equalsIgnoreCase(const CString& string) const;
    
    /////////////////////////////////
    // Opérateurs de concatenation //
    /////////////////////////////////
    CString &operator+=(const CString& string);
    
    //Pour pouvoir ajouter tout et n'importe quoi :)
    friend CString operator+(CString first, CString second);
    
    //Methodes de concatenation...
    CString &append(CString string);
    CString &append(int n, char character);
    
    //Et aussi d'insertion...
    CString &insertAt(int index, CString string);
    
    //////////////////////
    // Autres fonctions //
    //////////////////////
    //Est-ce que la chaine commence par prefix?
    bool startsWith(CString prefix) const;
    //Est-ce que la chaine se termine par suffix?
    bool endsWith(CString suffix) const;
    
    //Est-ce que la région de la chaine commencant a l'indice toffset
    //et de longueur len est identique à la region de other commencant
    //a ooffset et de meme longueur len (avec ou sans gestion de la casse)
    bool regionMatches(int toffset, CString other, int ooffset, int len,
                       bool ignoreCase=false) const;
    
    //Extraction de sous-chaine commencant a l'indice index jusqu'a la fin
    CString substring(int index) const;
    //Idem, mais sous-chaine de longueur length
    CString substring(int index, int length) const;
    
    //Indice de la premiere occurence de substring dans la chaine
    //-1 si non trouvé
    int indexOf(CString substring) const;
    //Idem, mais pour la derniere occurence de substring
    int lastIndexOf(CString substring) const;
    
    //Retourne la chaine || eniahc al enruoter // :P
    CString &reverse();
    
    //Fonction inutile pour savoir si une chaine est un palindrome ^_^
    bool isPalindrome() const;
    
    //Remplace toutes les occurences de string par byString
    //Retourne le nombre de changements effectues
    int replace(CString string, CString byString);
    //Remplace uniquement le premier
    int replaceFirst(CString string, CString byString);
    //Uniquement le dernier
    int replaceLast(CString string, CString byString);
    //Remplace la sous-chaine de longueur lg1 commencant a l'indice index
    //par byString.
    int replaceAt(int index, int lg1, CString byString);
    
    //Pour changer la casse de la chaine...
    CString &toLowerCase(); //En minuscules
    CString &toUpperCase(); //En majuscules
    //Premiere lettre de chaque mot en majuscules, le reste en minuscules.
    //Les mots sont séparés par tout caractere non-alphabétique.
    CString &capitalize();
    
    //Fonction "a la printf"
    CString &format(char *formatString, ...);
    
    //Redimensionne la chaine, en ajoutant character a la fin si necessaire
    //(len n'inclut pas l'\0 final!)
    CString &resize(int len, char character=' ');
    
    //Suppression d'espaces superflus
    CString &ltrim();
    CString &rtrim();
    CString &trim(); //Des deux cotes
    
    //Fonction de hachage facon java.lang.String (cf Java API)
    unsigned long long int hashCode() const;
    
    //Decoupage de la chaine... 
    //retourne un pointeur vers des chaines et 
    //le nombre de morceaux dans la variable par reference outNumber.
    CString *split(int &outNumber, char character) const;
    
    //Tokenisation : Les tokens sont separes par des espaces
    //OU compris entre simple ou double quotes.
    int countToken() const;
    void resetToken(){tokenIndex=0;};
    CString nextToken();
    CString endOfString() const;
};

#endif

 Conclusion

Petite remarque au passage, par rapport à l'allocation de mémoire : j'ai choisi d'allouer exactement l'espace nécessaire à chaque chaîne, ce qui implique l'obligation de réallouer de la mémoire à chaque fois qu'on effectue une concatenation par exemple. J'aurais aussi bien pu allouer la mémoire avec un peu de marge au départ, puis réallouer seulement en cas de nécessité, mais j'ai préféré la première solution, surtout dans l'optique d'un projet que j'envisage de réaliser et qui utilise beaucoup de chaines de caractères : j'ai préféré optimiser la RAM consommée plutot que le temps d'allocation de mémoire :)

A part ca... il reste peut-etre des bugs, malgre mes nombreux tests, je n'ai peut-etre pas pensé a essayer tous les coups tordus qui peuvent survenir ;) Donc si vous en trouvez, prevenez-moi! Et si vous avez des idées de méthodes à ajouter, dites-le moi aussi, je voudrais enrichir ma classe au maximum.

 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


 Historique

24 août 2004 08:51:53 :
28/04/2004 : Quelques modifications (merci a djl pour ses commentaires) : ==> Utilisation d'une variable membre pour mémoriser la longueur ==> Suppressions des const inutiles (!) et ajout de quelques const utiles oubliés ==> Modification de setPtr ==> Ajout d'un petit programme (Essai.cpp) utilisant la classe La modification concernant la longueur étant une assez grosse modif', j'espere qu'elle n'a pas introduit de bugs qui seraient passés à travers mes verifications
13 septembre 2004 08:24:24 :
Modification des headers utilisés...

 Sources du même auteur

Source avec Zip Source avec une capture UTILISATION DE COULEURS EN MODE CONSOLE [ANSI COLOR CODES]

 Sources de la même categorie

EVALUATION D'UNE CHAÎNE DE CARACTÈRES AVEC UN ARBRE BINAIRE par pabbati
Source avec Zip DICTIONNAIRE DANS UN ARBRE BINAIRE par pabbati
CALCUL DE CLEF RIB par Renfield
Source avec Zip [C] WD_STRING V2.2 par cyberripper
Source avec Zip LES STRING EN C, AFFECTATION, CONCATÉNATION, SPLIT, ... par appranting

Commentaires et avis

Commentaire de djl le 23/08/2004 14:52:47

deja bravo pour le code, la classe est assez complete et fonctionnelle

quelque remarque en passant, tu devrais stocker la taille dans une variable et faire un ascesseur inline plutot que de faire appel a chaque fois à strlen, ca peux devenir penalisant lors de plusieurs appels dans une boucle

ne specifie pas const une variable passé par
valeur "const int number" ca n'a aucune utilité

a quoi sert setPtr ? tu as deja le constructeur char* et l'operateur = char*

Commentaire de Soilwork9 le 23/08/2004 16:34:54

Salut, et merci pour ton message!
Pour la longueur, tu as surement raison, je vais voir si je peux mettre a jour une variable représentant la longueur dans la méthode reallocation. Mais je dois verifier qu'il n'y a aucune méthode qui mette a jour la chaine sans passer par reallocation (raccourcissement de chaine en inserant juste un \0, par exemple)...

Pour le const : ARF! Ne me demande pas pourquoi j'ai fait ca, je ne saurais pas te repondre ;p Je devais etre dans une periode const a ce moment la, j'en mettais partout, lol. 'fin bon, c'est enlevé, et on fera comme si ca n'etait jamais arrivé ^_^

setPtr ne sert a rien, un peu comme isPalindrome peut-etre (lol), mais en plus setPtr est mal fait (mauvaise utilisation de strcpy, a priori... Pas de réallocation). Vais peut-etre le virer aussi ;)

Merci en tout cas, et a plus tard!
++
Soilwork

Commentaire de magic_Nono le 24/08/2004 09:35:59

Bien...
Je déconseille cependant le nom de CString deja utilisé par les MFC, ça peut créer des confusions...

Une remarque : ton opérateur de réallocation vire tout ce que pouvait contenir ta chaine...

Magicalement...
Nono.

Commentaire de magic_Nono le 24/08/2004 09:55:42

rq2 : pq des  ";" après chaque méthode définie ds le header?

à quoi sert equals, == suffit

une des 2 fonctions suivantes, est inutiles:
    CString substring(int index) const;
    CString substring(int index, int length) const;
il suffit de faire le distingo au sein d'une seule
    CString substring(int index, int length=-1) const;

idem, rassemble
   CString &toLowerCase(); //En minuscules
    CString &toUpperCase(); //En majuscules
    CString &capitalize();

en une seule fonc

etc

sinon, je retrouve po mal mes BString & +

Magicalement...


Commentaire de magic_Nono le 24/08/2004 10:01:10

1 dernier pr la rte :

   if(strcasecmp(ptr, string.getPtr())==0)
        return true;
    return false;

no comment

Commentaire de Soilwork9 le 24/08/2004 14:58:36

C'est marrant, je savais que tu posterais un commentaire ici ;) Je t'ai deja vu faire de la pub pour tes BString dans des commentaires pour d'autres classes de chaines, en survolant un peu le contenu de ce site. ~_^ En tout cas, merci pour le "Bien..".

En ce qui concerne le nom de la classe, a vrai dire, les MFC... Erm, je m'en moque un peu...! Je nomme mes classes comme ca (C + Nom de classe : CString, CMachin, CTruc), je vais pas faire une exception parce que c'est deja pris par un truc que je n'utilise pas de toute facon ;) Pour la réallocation, effectivement, tu as raison, et c'est volontaire et normal!

Les méthodes equals, et les deux substring, ce sont des equivalences avec Java, pour ceux qui ont pris l'habitude d'utiliser les String de ce langage (Moi, en l'occurence!). Tu aurais aussi pu demander pourquoi append alors qu'il y a les operateurs + et +=, etc...
Je ne pense pas que rassembler les méthodes pour changer la casse en une seule soit une bonne idee : comme ca, le nom de la méthode indique clairement ce qu'elle fait, et je ne vois pas trop ou est l'avantage de ce que tu proposes (??). D'ailleurs en réalité, je vois pas exactement ce que tu proposes!

Pour ton dernier exemple, j'aurais certes pu ecrire
return (! strcasecmp( ... ) );
Mais je ne trouve pas ca vraiment clair. Et puis ca change pas grand chose, a vrai dire.

Voila, merci pour les commentaires. J'irai voir ta BString! ^^
++
Soilwork

Commentaire de magic_Nono le 24/08/2004 15:19:27

'lo

return (strcasecmp( ... ) ==0);
va très bien...

l'utilisation du Cxxx est effectivement une bonne convention & j'ai déjà expliqué pq j'aV opté pr des Bxxx.

Dans le cas des string, tu peux eventuellement géner des personnes ne voulant reprendre que des parties de ton codes mais après, C toi qui voit.

pour ma bibli
attend dc que je mette à jour toutes mes bibli
(prochainement)


pour les substring, je pense que tu m' a compris

sinon, fais comme tu veux,
je pense qu'il vaut mie avoir un nombre plus petit de fonctions avec eventuellementplus de paramètres(éventuellement optionnels)
mais C un choix et po de pb si tu opte pr une politique d'une multitude de petites fonctions...


autrement j'aV remarqué le parallèle à java... je trouve ces doublons inutils mais pourquoi pas...

Bon, je completerai plus tard
++
Nono.

Commentaire de djl le 24/08/2004 18:11:35

c'est ridicule de s'embeter avec les noms en c++, les namespaces sont la pour ca

Soilwork9 > si en java c'est equals cc'est parce que justement java ne supporte pas (entre autre) la surcharge des operateurs

Commentaire de Soilwork9 le 25/08/2004 08:05:36

djl > Yep, mais bon, ca change rien à la présence de equals dans ma classe ;) Et puis dans le cas des String, on trouve aussi les operateurs +, += et == (et ca ne m'est jamais venu a l'idee de faire une classe qui derive de String : ca marche tellement bien, lol)

Nono > Je préfère faire des fonctions aussi claires et lisibles que possible, et dont le nom indique ce qu'elles font. Si je commence a faire des methodes qui prennent 50 parametres et qui font 50 trucs differents dans la meme methode, pour une classe aussi simple que celle-la, je ne sais pas ou je vais me retrouver en attaquant un gros projet !

Et en ce qui concerne les "doublons" (les méthodes "Java"), c'est comme tout : c'est inutile si tu ne t'en sers pas ! ^_^

J'ai commencé à regarder ta BString, et je suis... plutot perplexe. Mais ce n'est pas l'endroit pour en parler, donc je te laisserai un message sur la page appropriée.

++
Soilwork

Commentaire de guill76 le 04/08/2007 00:03:37

Bonjour,

Je viens d'utiliser cette classe de string qui est très bien faite, je trouve, mais j'ai rencontré le bug suivant:
L'auto-affection désalloue la mémoire mais ne la recrée pas.
voici le code utilisé avec gcc sur mingw:
int main()
{
CString test="test d'auto-affectation";
cout<<test<<endl;//affiche "test d'auto-affectation"
test=test;
cout<<test<<endl;//affiche o$? en sortie
}  
Il faudrait peut-etre créer une variable temporaire lorsque this=(objet de recopie) avant la réallocation?

  

Commentaire de guill76 le 06/08/2007 19:11:58

Correction:
Il faut un test supplémentaire pour ne pas réallouer la place pour la chaine :
CString &CString::operator=(const CString& string)
{
  if (this!=&string)
  {
    reallocation(string.length()+1);
    strcpy(ptr, string.getPtr());
  }
  return (*this);
}

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Mai 2013
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Photothèque

A découvrir



 
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 : 0,655 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales