Vous pouvez récupérer tous les programmes en un seul tar.gz sur Telecharger String . Pour obtenir ce fichier, dans un butineur web, sauvez ce fichier en type 'texte'.
// // Auteur : Al Dev // Utilisez la classe string ou cette classe // // Pour prévenir les fuites de mémoire - une classe caractère qui gère les // variables caractères. // Préférez toujours l'utilisation de la classe string à char[] et char *. // // // Pour compiler et tester ce programme, utilisez - // g++ String.cpp #include "String.h" //#include <sys/va_list.h> pour Format() //#include <sys/varargs.h> pour Format() // Variables globales.... //String *String::_global_String = NULL; // variable globale list<String> String::explodeH; String::String() { debug_("In cstr()", "ok"); sval = (char *) my_malloc(sizeof(char)* INITIAL_SIZE); _pString = NULL; } String::String(char *bb) { unsigned long tmpii = strlen(bb); sval = (char *) my_malloc(sizeof(char)* tmpii); strncpy(sval, bb, tmpii); sval[tmpii] = '\0'; //debug_("In cstr(char *bb) bb", bb); debug_("In cstr(char *bb) sval", sval); #ifdef DEBUG //fprintf(stderr, "\nAddress of sval=%x\n", & sval); //fprintf(stderr, "\nAddress of this-pointer=%x\n", this); #endif // DEBUG _pString = NULL; } String::String(char *bb, int start, int slength) { unsigned long tmpii = strlen(bb); if (start> (int) tmpii || start < 0) { cerr << "\nString(char *, int, int) - start is out of bounds!!\n" << endl; exit(1); } sval = (char *) my_malloc(sizeof(char)* slength); strncpy(sval, & bb[start], slength); sval[slength] = '\0'; //debug_("In cstr(char *bb) bb", bb); debug_("In cstr(char *bb) sval", sval); #ifdef DEBUG //fprintf(stderr, "\nAddress of sval=%x\n", & sval); //fprintf(stderr, "\nAddress of this-pointer=%x\n", this); #endif // DEBUG _pString = NULL; } String::String(int bb) { sval = (char *) my_malloc(NUMBER_LENGTH); // int avec 70 chiffres max sprintf(sval, "%d", bb); debug_("In cstr(int bb) sval", sval); _pString = NULL; } String::String(unsigned long bb) { sval = (char *) my_malloc(NUMBER_LENGTH); // unsigned long avec 70 chiffres max sprintf(sval, "%lu", bb); debug_("In cstr(unsigned long bb) sval", sval); _pString = NULL; } String::String(long bb) { sval = (char *) my_malloc(NUMBER_LENGTH); // long avec 70 chiffres max sprintf(sval, "%ld", bb); debug_("In cstr(long bb) sval", sval); _pString = NULL; } String::String(float bb) { sval = (char *) my_malloc(NUMBER_LENGTH); // float avec 70 chiffres max sprintf(sval, "%f", bb); debug_("In cstr(float bb) sval", sval); _pString = NULL; } String::String(double bb) { sval = (char *) my_malloc(NUMBER_LENGTH); // double avec 70 chiffres max sprintf(sval, "%f", bb); debug_("In cstr(double bb) sval", sval); _pString = NULL; } // Constructeur par recopie utilisé par l'opérateur + String::String(const String & rhs) { // Effectue une copie en profondeur à la place de la copie superficielle par défaut du compilateur debug_("In copy-cstr()", "ok"); unsigned long tmpii = strlen(rhs.sval); sval = (char *) my_malloc(sizeof(char)* tmpii); strncpy(sval, rhs.sval, tmpii); sval[tmpii] = '\0'; _pString = NULL; } // Cette fonction fournit une compatibilité avec le code Java String::String(StringBuffer sb) { debug_("In String(StringBuffer)", "ok"); unsigned long tmpii = strlen(sb.sval); sval = (char *) my_malloc(sizeof(char)* tmpii); strncpy(sval, sb.sval, tmpii); sval[tmpii] = '\0'; _pString = NULL; } // Utilisé par la classe StringBuffer. Utilise la variable dummy // pour différentes signatures. // La classe StringBuffer imite le StringBuffer de Java String::String(int size, bool dummy) { sval = (char *) my_malloc(sizeof(char)* size); debug_("In cstr(int size, bool dummy) sval", sval); #ifdef DEBUG //fprintf(stderr, "\nAddress of sval=%x\n", & sval); //fprintf(stderr, "\nAddress of this-pointer=%x\n", this); #endif // DEBUG _pString = NULL; } String::~String() { debug_("In dstr sval", sval); #ifdef DEBUG //fprintf(stderr, "\nAddress of sval=%x\n", & sval); //fprintf(stderr, "\nAddress of this-pointer=%x\n", this); #endif // DEBUG my_free(sval); //delete [] sval; sval = NULL; delete _pString; _pString = NULL; } inline void String::_allocpString() { // _pString will be deleted in destructor if (!_pString) // if (_pString == NULL) _pString = new String(this->sval); else *_pString = this->sval; } // DOIT utiliser un pointeur-sur-pointeur **aa, sinon la mémoire utilisée // par l'argument N'est PAS libérée ! /* inline void String::_free_glob(String **aa) { debug_("called _free_glob()", "ok" ); if (*aa != NULL) // (*aa != NULL) { debug_("*aa is not null", "ok"); delete *aa; *aa = NULL; } //else debug_("*aa is null", "ok"); //if (*aa == NULL) debug_("*aa set to null", "ok"); } */ // Imite le charAt de java.lang.String char String::charAt(int where) { verifyIndex(where); return (sval[where]); } // Imite la fonction getChars de java.lang.String // sourceStart spécifie l'indice du début de la sous-chaîne // et sourceEnd spécifie l'indice juste après la fin de la sous-chaîne désirée // Ainsi la sous-chaîne contient les caractères de sourceStart jusqu'à // (sourceEnd - 1). Le tableau qui va recevoir les caractères est target. // targetStart est l'indice dans target à partir duquel la copie sera effectuée. // Il convient de s'assurer que le tableau target est assez grand pour pouvoir contenir // le nombre de caractères désiré. // Par exemple getChars(3, 6, aa, 0) sur "ABCDEFGHIJK" donne aa ="DEF" void String::getChars(int sourceStart, int sourceEnd, char target[], int targetStart) { verifyIndex(sourceStart); verifyIndex(sourceEnd); if (sourceEnd>= sourceStart) { strncpy(& target[targetStart], & sval[sourceStart], sourceEnd - sourceStart); target[targetStart + (sourceEnd - sourceStart)] = 0; } else { cerr << "\ngetChars() - SourceEnd is greater than SourceStart!!\n" << endl; exit(1); } } // Imite getChars de java.lang.String // Retourne un tableau caractères contenant la chaîne entière char* String::toCharArray() { return (sval); } // Imite getBytes de java.lang.String // Retourne un tableau caractères contenant la chaîne entière char* String::getBytes() { return (sval); } // Imite equals de java.lang.String bool String::equals(String str2) // voir aussi l'opérateur == { return ( _equalto(str2.sval)); } // Imite equals de java.lang.String bool String::equals(char *str2) // voir aussi l'opérateur == { return ( _equalto(str2)); } // Imite equalsIgnoreCase de java.lang.String bool String::equalsIgnoreCase(String str2) { String aa, bb; aa = this->toLowerCase(); bb = str2.toLowerCase(); return ( aa._equalto(bb.sval) ); } // Imite regionMatches de java.lang.String // startIndex spécifie l'indice à partir duquel débute la région dans l'objet // String invoquant la méthode. La chaîne est comparée à str2. L'indice à partir // duquel la comparaison commencera dans str2 est spécifié par str2Index // La longueur de la sous-chaîne comparée est numChars. bool String::regionMatches(int startIndex, String str2, int str2StartIndex, int numChars) { verifyIndex(startIndex); str2.verifyIndex(str2StartIndex); if (strncmp(& this->sval[startIndex], & str2.sval[str2StartIndex], numChars) == 0) return true; else return false; } // Imite regionMatches de java.lang.String // Il s'agit de la version surchargée de regionMatches // Si ignoreCase vaut true, la casse des caractères est ignorée, sinon // la casse est significative (i.e. si ignoreCase vaut true alors ignore la // casse et compare) // startIndex spécifie l'indice à partir duquel débute la region dans l'objet // String invoquant la méthode. La chaîne est comparée à str2. L'indice à partir // duquel la comparaison commencera dans str2 est spécifié par str2Index // La longueur de la sous-chaîne comparée est numChars. bool String::regionMatches(bool ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars) { if (ignoreCase) // if (ignoreCase == true) { verifyIndex(startIndex); str2.verifyIndex(str2StartIndex); String string1, string2; string1 = this->toLowerCase(); string2 = str2.toLowerCase(); if (strncmp(& string1.sval[startIndex], & string2.sval[str2StartIndex], numChars) == 0) return true; else return false; } else { return regionMatches(startIndex, str2, str2StartIndex, numChars); } } // Imite toLowerCase de java.lang.String // String ss("sometest"); // String egg = ss.toLowerCase(); String String::toLowerCase() { _allocpString(); for (long tmpii = strlen(_pString->sval); tmpii>= 0; tmpii--) { _pString->sval[tmpii] = tolower(_pString->sval[tmpii]); } return *_pString; // return the object now } // Imite toUpperCase de java.lang.String // String ss("sometest"); // String egg = ss.toUpperCase(); String String::toUpperCase() { _allocpString(); for (long tmpii = strlen(_pString->sval); tmpii>= 0; tmpii--) { _pString->sval[tmpii] = toupper(_pString->sval[tmpii]); } return *_pString; // return the object now } // Imite startsWith de java.lang.String bool String::startsWith(String str2) { if (!strncmp(this->sval, str2.sval, strlen(str2.sval) )) // if (strncmp() == 0) return true; else return false; } // Imite startsWith de java.lang.String // Fonction surchargée bool String::startsWith(char *str2) { int lenstr2 = strlen(str2); if (!strncmp(this->sval, str2, lenstr2)) // if (strncmp() == 0) return true; else return false; } // Imite endsWith de java.lang.String bool String::endsWith(String str2) { // str2 doit être plus courte que la chaîne courante if (strlen(str2.sval)> strlen(sval)) return false; if (!strncmp(& this->sval[strlen(sval) - strlen(str2.sval)], str2.sval, strlen(str2.sval) )) // if (strncmp() == 0) return true; else return false; } // Imite endsWith de java.lang.String bool String::endsWith(char *str2) { // str2 doit être plus courte que la chaîne courante if (strlen(str2)> strlen(sval)) return false; if (!strncmp(& this->sval[strlen(sval) - strlen(str2)], str2, strlen(str2) ) ) // if (strncmp() == 0) return true; else return false; } // Imite compareTo de java.lang.String // Pour les tris, vous devez savoir si l'un est plus petit, égal ou plus grand que l'autre. // Une chaîne est plus petite qu'une autre si elle arrive avant l'autre dans l'ordre // lexicographique. Un chaîne est plus grande qu'une autre si elle arrive après. // Négatif --> la chaîne courante est plus petite que str2 // Positif --> la chaîne courante est plus grande que str2 // Zero --> les deux chaînes sont égales int String::compareTo(String str2) { int flag = 0; // Compare les lettres dans la chaîne à chaque lettre de str2 for (int tmpii = 0, tmpjj = strlen(sval), tmpkk = strlen(str2.sval); tmpii < tmpjj; tmpii++) { if (tmpii> tmpkk) break; if (sval[tmpii] == str2.sval[tmpii]) flag = 0; else if (sval[tmpii]> str2.sval[tmpii]) { flag = 1; break; } else // if (sval[tmpii] < str2.sval[tmpii]) { flag = -1; break; } } return flag; } // Imite compareTo de java.lang.String // Fonction surchargée de compareTo int String::compareTo(char *str2) { int flag = 0; // Compare les lettres de la chaîne courante avec chaque lettre de str2 for (int tmpii = 0, tmpjj = strlen(sval), tmpkk = strlen(str2); tmpii < tmpjj; tmpii++) { if (tmpii> tmpkk) break; if (sval[tmpii] == str2[tmpii]) flag = 0; else if (sval[tmpii]> str2[tmpii]) { flag = 1; break; } else // if (sval[tmpii] < str2[tmpii]) { flag = -1; break; } } return flag; } // Imite compareToIgnoreCase de java.lang.String int String::compareToIgnoreCase(String str2) { String tmpaa = this->toLowerCase(), tmpbb = str2.toLowerCase(); return tmpaa.compareTo(tmpbb); } // Imite compareToIgnoreCase de java.lang.String // Version surchargée int String::compareToIgnoreCase(char *str2) { String tmpaa = this->toLowerCase(), tmpcc(str2), tmpbb = tmpcc.toLowerCase(); return tmpaa.compareTo(tmpbb); } // Imite indexOf de java.lang.String // Cherche la premiere occurrence d'un caractère ou d'une chaîne. // Retourne l'indice à partir duquel le caractère ou la chaîne // a été trouvé, ou -1 en cas d'échec. int String::indexOf(char ch, int startIndex = 0) { verifyIndex(startIndex); int ii = startIndex; for (; ii < (int) strlen(sval); ii++) { if (sval[ii] == ch) break; } if (ii == (int) strlen(sval)) return -1; return ii; } // Imite indexOf de java.lang.String // Version surchargée int String::indexOf(char *str2, int startIndex = 0) { verifyIndex(startIndex); char * tok; long res = -1; if ( !isNull() ) { tok = strstr(sval + startIndex, str2); if (tok == NULL) res = -1; else res = (int) (tok - sval); } return res; } // Imite indexOf de java.lang.String // Version surchargée int String::indexOf(String str2, int startIndex = 0) { verifyIndex(startIndex); char * tok; long res = -1; if ( !isNull() ) { tok = strstr(sval + startIndex, str2.sval); if (tok == NULL) res = -1; else res = (int) (tok - sval); } return res; } // Imite lastIndexOf de java.lang.String // Cherche pour la dernière occurrence d'un caractère ou d'une chaîne. // Retourne l'indice à partir duquel le caractère ou la chaîne a été trouvé // ou -1 en cas d'échec. int String::lastIndexOf(char ch, int startIndex = 0) { verifyIndex(startIndex); int ii; // Commence la recherche par le dernier caractère de la chaîne if (!startIndex) // if (startIndex == 0) ii = strlen(sval); else ii = startIndex; for (; ii> -1; ii--) { if (sval[ii] == ch) break; } if (!ii && sval[ii] != ch) // if (ii == 0) return -1; return ii; } // Imite lastIndexOf de java.lang.String // Version surchargée int String::lastIndexOf(char *str2, int startIndex = 0) { verifyIndex(startIndex); char *tok = NULL; int res = -1; register char *tmpaa = strdup(sval); // ici malloc if (!tmpaa) // tmpaa == NULL { cerr << "\nMemory alloc failed in strdup in lastIndexOf()\n" << endl; exit(-1); } if (!startIndex) // if (startIndex == 0) startIndex = strlen(sval); else tmpaa[startIndex+1] = 0; for (int ii = 0; ii <= startIndex; ii++) { tok = strstr(& tmpaa[ii], str2); if (tok == NULL) break; else { res = (int) (tok - tmpaa); debug_("res", res); ii = res; // saute vers l'endroit qui correspond (+1 dans la boucle for) } } free(tmpaa); debug_("res", res); debug_("indexOf", & sval[res]); return res; } // Imite lastIndexOf de java.lang.String // Version surchargée int String::lastIndexOf(String str2, int startIndex = 0) { verifyIndex(startIndex); char *tok = NULL; int res = -1; register char *tmpaa = strdup(sval); // ici malloc if (!tmpaa) // tmpaa == NULL { cerr << "\nMemory alloc failed in strdup in lastIndexOf()\n" << endl; exit(-1); } if (!startIndex) // if (startIndex == 0) startIndex = strlen(sval); else tmpaa[startIndex+1] = 0; for (int ii = 0; ii <= startIndex; ii++) { tok = strstr(& tmpaa[ii], str2.sval); if (tok == NULL) break; else { res = (int) (tok - tmpaa); debug_("res", res); ii = res; // saute vers l'endroit qui correspond (+1 dans la boucle for) } } free(tmpaa); debug_("res", res); debug_("indexOf", & sval[res]); return res; } // Imite substring de java.lang.String // startIndex spécifie l'indice de début, et endIndex l'indice de fin. // La chaîne retournée contient tous les caractères de l'indice de début // jusqu'à l'indice de fin, mais sans l'inclure. String String::substring(int startIndex, int endIndex = 0) { String tmpstr = String(sval); tmpstr._substring(startIndex, endIndex); return tmpstr; } // Imite concat de java.lang.String String String::concat(String str2) { return (*this + str2); } // Imite concat de java.lang.String // Version surchargée String String::concat(char *str2) { return (*this + str2); } // Imite replace de java.lang.String // Remplace toutes les occurrences de la chaîne 'original' par // 'replacement' dans 'sval' String String::replace(char original, char replacement) { // Par exemple - // replace('A', 'B') dans sval = "des AAA et AAACC" // retourne sval = "des BBB et BBBCC" //String *tmpstr = new String(sval); Utilise le constructeur de recopie par défaut String tmpstr(sval); for (int ii = 0, len = strlen(sval); ii < len; ii++) { if (tmpstr.sval[ii] == original) tmpstr.sval[ii] = replacement; } return tmpstr; // utilise le constructeur de recopie pour faire une copie } // Imite replace de java.lang.String // Version surchargée // Remplace toutes les occurrences de la chaîne 'original' par // 'replacement' dans 'sval' String String::replace(char *original, char *replacement) { char *tok = NULL, *bb; register char *aa = strdup(sval); int lenrepl = strlen(replacement); // Alloue l'espace pour bb { // portée locale int tmpii = 0; for (int ii = 0; ;ii++) { tok = strstr(& aa[ii], original); if (tok == NULL) break; else { ii = ii + (int) (tok -aa); tmpii++; } } if (!tmpii) // tmpii == 0, pas de 'original' trouvé return (String(sval)); // retourne la chaîne originale tmpii = strlen(sval) + (tmpii * lenrepl) + 20; debug_("strstr tmpii", tmpii ); bb = (char *) malloc(tmpii); memset(bb, 0, tmpii); } for (int res = -1; ;) { debug_("aa", aa); tok = strstr(aa, original); if (tok == NULL) { strcat(bb, aa); break; } else { res = (int) (tok - aa); strncat(bb, aa, res); strcat(bb, replacement); //bb[strlen(bb)] = 0; debug_("res", res ); debug_("bb", bb ); strcpy(aa, & aa[res+lenrepl]); } } debug_("bb", bb ); free(aa); String tmpstr(bb); free(bb); return tmpstr; } /* une autre méthode pour faire le remplacement mais lente... String String::replace(char *original, char *replacement) { // Par exemple - // replace("AAA", "BB") avec sval = "des AAA et AAACC" // retourne sval = "des BB et BBCC" String bb(this->before(original).sval); if (strlen(bb.sval) == 0) return String(sval); // retourne la chaîne originale bb += replacement; String tmpaa(this->sval), cc, dd; for (;;) { cc = tmpaa.after(original).sval; debug_("cc", cc.sval ); if (!strlen(cc.sval)) // if (strlen(cc.sval) == 0) break; dd = cc.before(original).sval; if (strlen(dd.sval) == 0) { bb += cc; break; } else { bb += dd; bb += replacement; } tmpaa = cc; } debug_("bb.sval", bb.sval ); return bb; } */ // Imite replace de Java - StringBuffer String String::replace (int startIndex, int endIndex, String str) { verifyIndex(startIndex); verifyIndex(endIndex); int tmpjj = strlen(str.sval); if (tmpjj == 0) return *this; int tmpii = endIndex-startIndex-1; if (tmpjj < tmpii) // la longueur de str est plus petite que les indices specifies. tmpii = tmpjj; debug_("sval", sval); debug_("str.sval", str.sval); strncpy(& sval[startIndex], str.sval, tmpii); sval[startIndex+tmpii] = 0; debug_("sval", sval); return *this; } // Imite trim de java.lang.String String String::trim() { //String *tmpstr = new String(sval); String tmpstr(sval); tmpstr._trim(); debug_("tmpstr.sval", tmpstr.sval); return tmpstr; // utilise le constructeur par recopie pour faire une copie } // Imite insert de java.lang.String String String::insert(int index, String str2) { String tmpstr(this->insert(str2.sval, index).sval); debug_("tmpstr.sval", tmpstr.sval); return tmpstr; } // Imite insert de java.lang.String String String::insert(int index, char ch) { char aa[2]; aa[0] = ch; aa[1] = 0; String tmpstr(this->insert(aa, index).sval); debug_("tmpstr.sval", tmpstr.sval); return tmpstr; } // Imite deleteCharAt de java.lang.String String String::deleteCharAt(int loc) { String tmpstr(sval); tmpstr._deleteCharAt(loc); return tmpstr; } // Imite delete de java.lang.String // Note : -->le nom Java est "delete()", mais c'est un mot résérvé inutilisable en C++ // startIndex spécifie l'indice du premier caractère à enlever, // et endIndex l'indice juste après le dernier caractère à supprimer. // Ainsi, la sous-chaîne supprimée s'etend de startIndex à (endIndex - 1). String String::deleteStr(int startIndex, int endIndex) { // Par exemple - // deleteStr(3,3) avec val = 'pokemon' retourne 'poon' String tmpstr(sval); tmpstr._deleteStr(startIndex, endIndex); return tmpstr; } // Imite reverse de java.lang.String String String::reverse() { // Par exemple : // reverse() sur "12345" retourne "54321" String tmpstr(sval); tmpstr._reverse(); return tmpstr; } // Imite valueOf de java.lang.String String String::valueOf(char chars[], int startIndex, int numChars) { verifyIndex(startIndex); int ii = strlen(chars); if (startIndex> ii) { cerr << "\nvalueOf() - startIndex greater than string length of" << "string passed" << endl; exit(0); } if ( (numChars+startIndex)> ii) { cerr << "\nvalueOf() - numChars exceeds the string length of" << "string passed" << endl; exit(0); } char *aa = strdup(chars); aa[startIndex + numChars] = 0; String tmpstr(& aa[startIndex]); free(aa); return tmpstr; } // Imite ensureCapacity de java.lang.String // Utilisé par la classe StringBuffer. // Pré-alloue la place pour un certain nombre de caractères. // Utile si vous savez à l'avance que vous allez rajouter un grand nombre // de petites chaînes à un StringBuffer void String::ensureCapacity(int capacity) { sval = (char *) my_realloc(sval, capacity); sval[0] = '\0'; debug_("In ensureCapacity(int capacity) sval", sval); } // Imite setLength de java.lang.String // Utilise par la classe StringBuffer. void String::setLength(int len) { sval = (char *) my_realloc(sval, len); sval[0] = '\0'; debug_("In ensureCapacity(int len) sval", sval); } // Imite setCharAt de StringBuffer void String::setCharAt(int where, char ch) { verifyIndex(where); sval[where] = ch; debug_("in StringBuffer dstr()", "ok"); } // ---- Fin des fonctions imitant java.lang.String ----- // Version surchargée, modifie directement l'objet // La variable dummy donne une signature différente à la fonction. void String::substring(int startIndex, int endIndex, bool dummy) { this->_substring(startIndex, endIndex); } inline void String::_substring(int startIndex, int endIndex) { verifyIndex(startIndex); verifyIndex(endIndex); if (!endIndex) // endIndex == 0 strcpy(sval, & sval[startIndex] ) ; else { if (endIndex> startIndex) { strcpy(sval, & sval[startIndex] ) ; sval[endIndex -startIndex] = 0; } else { cerr << "\n_substring() - startIndex is greater than endIndex!!\n" << endl; exit(-1); } } } // Version surchargée, modifie directement l'objet String String::deleteStr(int startIndex, int endIndex, bool dummy) { this->_deleteStr(startIndex, endIndex); return *this; } inline void String::_deleteStr(int startIndex, int endIndex) { verifyIndex(startIndex); verifyIndex(endIndex); // Par exemple - // deleteStr(3,3) avec val = 'pokemon' retourne 'poon' char *tmpaa = strdup(sval); // ici malloc strcpy(& tmpaa[startIndex], & tmpaa[endIndex]); *this = tmpaa; free(tmpaa); } // Version surchargée, modifie directement l'objet String String::deleteCharAt(int loc, bool dummy) { this->_deleteCharAt(loc); return *this; } inline void String::_deleteCharAt(int loc) { char *tmpaa = strdup(sval); // ici malloc strcpy(& tmpaa[loc], & tmpaa[loc+1]); *this = tmpaa; free(tmpaa); } // Retourne la chaîne avant regx. Trouve la première occurrence de regx. String String::at(char *regx) { char *tok = NULL; tok = strstr(sval, regx); if (tok == NULL) return(String("")); else { int res = (int) (tok - sval); char *lefttok = strdup(sval); memset(lefttok, 0, strlen(sval)); strcpy(lefttok, & sval[res]); String tmpstr(lefttok); free(lefttok); return(tmpstr); } } // Retourne la chaîne avant regx. Trouve la première occurrence de regx. String String::before(char *regx) { char *tok = NULL; tok = strstr(sval, regx); if (tok == NULL) return(String("")); else { int res = (int) (tok - sval); char *lefttok = strdup(sval); lefttok[res] = 0; String tmpstr(lefttok); free(lefttok); return(tmpstr); } } // Retourne la chaîne après regx. Trouve la première occurrence de regx. String String::after(char *regx) { char *tok = NULL; tok = strstr(sval, regx); if (tok == NULL) return(String("")); else { int res = (int) (tok - sval); char *lefttok = strdup(sval); memset(lefttok, 0, strlen(sval)); strcpy(lefttok, & sval[res + strlen(regx)]); String tmpstr(lefttok); free(lefttok); return(tmpstr); } } // Divise la chaîne et retourne une liste via le pointeur de tête // de liste explodeH. // Voir aussi token(). void String::explode(char *seperator) { char *aa = NULL, *bb = NULL; aa = (char *) my_malloc(strlen(sval)); for (bb = strtok(aa, seperator); bb != NULL; bb = strtok(NULL, seperator) ) { String *tmp = new String(bb); String::explodeH.insert(String::explodeH.end(), *tmp); } my_free(aa); list<String>::iterator iter1; // voir include/g++/stl_list.h debug_("Before checking explode..", "ok"); if (String::explodeH.empty() == true ) { debug_("List is empty!!", "ok"); } for (iter1 = String::explodeH.begin(); iter1 != String::explodeH.end(); iter1++) { if (iter1 == NULL) { debug_("Iterator iter1 is NULL!!", "ok" ); break; } debug_("(*iter1).sval", (*iter1).sval); } } // Version surchargée de explode(). Retourne un tableau // de chaînes et le nombre total dans la référence strcount // Voir aussi token(). String *String::explode(int & strcount, char seperator = ' ') { String aa(sval); aa.trim(true); strcount = 0; for (int ii = 0, jj = strlen(aa.sval); ii < jj; ii++) { if (aa.sval[ii] == seperator) strcount++; } String *tmpstr = new String[strcount+1]; if (!strcount) // strcount == 0 tmpstr[0] = aa.sval; else { for (int ii = 0; ii <= strcount; ii++) tmpstr[ii] = aa.token(); } return tmpstr; } // Agrège les chaînes pointées par la tête de liste // explodeH et retourne la classe String. void String::implode(char *glue) { } // Agrège les chaînes pointées par la tête de liste // explodeH et retourne la classe String. void String::join(char *glue) { implode(glue); } // Répète la chaîne input n fois. String String::repeat(char *input, unsigned int multiplier) { // Pour exemple - // repeat("k", 4) retourne "kkkk" if (!input) // input == NULL { return (String("")); } char *aa = (char *) my_malloc(strlen(input) * multiplier); for (unsigned int tmpii = 0; tmpii < multiplier; tmpii++) { strcat(aa, input); } String tmpstr(aa); my_free(aa); return tmpstr; } // Renverse la chaîne. // Version surchargée de reverse(). Modifie directement l'objet. void String::reverse(bool dummy) { this->_reverse(); } inline void String::_reverse() { // Par exemple - // reverse() sur "12345" retourne "54321" char aa; unsigned long tot_len = strlen(sval); unsigned long midpoint = tot_len / 2; for (unsigned long tmpjj = 0; tmpjj < midpoint; tmpjj++) { aa = sval[tmpjj]; // variable temporaire de stockage sval[tmpjj] = sval[tot_len - tmpjj - 1]; // permute les valeurs sval[tot_len - tmpjj - 1] = aa; // permute les valeurs } } // Change certain caractères. // Par exemple ("abcd", "ABC") change toutes les occurrences de chaque // caractère de 'from' en le caractère correspondant dans 'to' String String::tr(char *from, char *to) { int lenfrom = strlen(from), lento = strlen(to); if (lento> lenfrom) lento = lenfrom; // choisit le min else if (lento < lenfrom) lenfrom = lento; // choisit le min debug_("lento", lento); register char *aa = strdup(sval); for (int ii = 0, jj = strlen(sval); ii < jj; ii++) // pour chaque caractère dans val { for (int kk = 0; kk < lento; kk++) // pour chaque caractère dans "from" { if (aa[ii] == from[kk]) aa[ii] = to[kk]; } } String tmpstr(aa); free(aa); return tmpstr; } // Centre le texte String String::center(int padlength, char padchar = ' ') { // Par exemple - // center(10, '*') avec sval="aa" retourne "****aa****" // center(10) avec sval="aa" retourne " aa " // Le résultat est une chaîne contenant 'padlength' caractères avec sval au milieu. int tmpii = sizeof(char) * (padlength + strlen(sval) + 10); char *aa = (char *) malloc(tmpii); memset(aa, 0, tmpii); for (int jj = 0, kk = (int) padlength/2; jj < kk; jj++) { aa[jj] = padchar; } strcat(aa, sval); for (int jj = strlen(aa), kk = jj + (int) padlength/2; jj < kk; jj++) { aa[jj] = padchar; } String tmpstr(aa); free(aa); return tmpstr; } // Formate la chaîne originale en plaçant <number> caractères <padchar> // entre chaque ensemble de mots délimités par des blancs. Les blancs en début et // en fin sont toujours supprimés. Si <number> est omis ou vaut 0, alors tous les // espaces de la chaîne sont supprimés. Par défaut, <number> vaut 0 et padchar ' '. String String::space(int number, char padchar = ' ') { // Par exemple - // space(3) avec sval = "Je ne sais pas" // retournera "Je ne sais pas" // space(1, '_') avec sval = "Un lieu profondement obscur" // retournera "Un_lieu_profondement_obscur" // space() avec sval = "Je sais cela" // retournera "Jesaiscela" debug_("this->sval", this->sval ); String tmpstr = this->trim().sval; debug_("tmpstr.sval", tmpstr.sval ); // compte les espaces int spacecount = 0; for (int ii = 0, jj = strlen(tmpstr.sval); ii < jj; ii++) { if (tmpstr.sval[ii] == ' ') spacecount++; } debug_("spacecount", spacecount); char ee[2]; ee[0] = padchar; ee[1] = 0; String bb = tmpstr.repeat(ee, spacecount); int tmpii = sizeof(char) * (strlen(tmpstr.sval) + (number * spacecount) + 20); char *aa = (char *) malloc(tmpii); memset(aa, 0, tmpii); for (int ii = 0, jj = strlen(tmpstr.sval); ii < jj; ii++) { if (tmpstr.sval[ii] == ' ') strcat(aa, bb.sval); else { ee[0] = sval[ii]; strcat(aa, ee); } } tmpstr = aa; free(aa); return tmpstr; } // Le résultat est une chaîne comprenant tous les caractères compris // entre <start> et <end> (inclus). String String::xrange(char start, char end) { // Par exemple - // xrange('a', 'j') retourne val = "abcdefghij" // xrange(1, 8) retourne val = "12345678" if (end < start) { cerr << "\nThe 'end' character is less than 'start' !!" << endl; return String(""); } // Note : 'end' est plus grand que 'start' ! Et ajoute +1 int tmpii = sizeof(char) * (end - start + 11); char *aa = (char *) malloc(tmpii); memset(aa, 0, tmpii); debug_("xrange tmpii", tmpii); for (int ii = start, jj = 0; ii <= end; ii++, jj++) { aa[jj] = ii; debug_("xrange aa[jj]", aa[jj] ); } String tmpstr(aa); free(aa); r