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 <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.
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.