Classe cstring : gestion de chaines de caractères en c++
Soyez le premier à donner votre avis sur cette source.
Vue 38 900 fois - Téléchargée 1 084 fois
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 ^_^
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.
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 <rim();
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.
Codes Sources
A voir également
- Cstring c
- C-string - Meilleures réponses
- Gestion des chaines - Meilleures réponses
- Cstring to char* ✓ - Forum - C / C++ / C++.NET
- C / C++ / C++.NET : Convertir un int en cstring - CodeS SourceS - Guide
- C / C++ / C++.NET : Classe cstring - CodeS SourceS - Guide
- C / C++ / C++.NET : Cstringconvert (manipulation des cstring) - CodeS SourceS - Guide
- [unicode] Convertir CString en Char ✓ - Forum - C
6 août 2007 à 19:11
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);
}
4 août 2007 à 00:03
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?
25 août 2004 à 08:05
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
- Messages postés
-
3011
- Date d'inscription
- jeudi 26 septembre 2002
- Statut
- Membre
- Dernière intervention
- 27 novembre 2004
724 août 2004 à 18:11
Soilwork9 > si en java c'est equals cc'est parce que justement java ne supporte pas (entre autre) la surcharge des operateurs
- Messages postés
-
1878
- Date d'inscription
- jeudi 16 octobre 2003
- Statut
- Membre
- Dernière intervention
- 16 mars 2011
124 août 2004 à 15:19
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.
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.