Classe cstring : gestion de chaines de caractères en c++

Soyez le premier à donner votre avis sur cette source.

Vue 37 823 fois - Téléchargée 1 042 fois

Télécharger le projet
Commenter

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 / Exemple : 


#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.
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Signaler
guill76
Messages postés
193
Date d'inscription
mercredi 24 août 2005
Statut
Membre
Dernière intervention
3 juin 2016
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);
}
Signaler
guill76
Messages postés
193
Date d'inscription
mercredi 24 août 2005
Statut
Membre
Dernière intervention
3 juin 2016
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?
Signaler
Soilwork9
Messages postés
16
Date d'inscription
lundi 9 août 2004
Statut
Membre
Dernière intervention
13 septembre 2004
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
Signaler
cs_djl
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
 7
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
Signaler
magic_Nono
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
 1
'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.
Afficher les 11 commentaires
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 (Soilwork9)