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ère.
// Préférez toujours l'utilisation de la classe String à char[] et char *.
//
#ifndef __STRING_H_
#define __STRING_H_
//#include <iostream> // ne pas utiliser iostream car le programme devient volumineux.
//#include <stdlib.h> // pour free() et malloc()
#include <string.h> // pour strcpy()
#include <ctype.h> // pour isspace()
#include <stdio.h> // pour sprintf()
#include <list.h> // pour sprintf()
#include <math.h> // pour modf(), rint()
#include "my_malloc.h"
#include "debug.h" // debug_(name, value) debug2_(name, value, LOG_YES)
const short INITIAL_SIZE = 50;
const short NUMBER_LENGTH = 70;
const int MAX_ISTREAM_SIZE = 2048;
class StringBuffer;
// une petite classe avec le STRICT MINIMUM de fonctions et de variables
// Cette classe doit être gardée petite...
class String
{
public:
String();
String(char bb[]); // nécessaire pour operator+
String(char bb[], int start, int slength); // sous-ensemble de caractères
String(int bb); // nécessaire pour operator+
String(unsigned long bb); // nécessaire pour operator+
String(long bb); // nécessaire pour operator+
String(float bb); // nécessaire pour operator+
String(double bb); // nécessaire pour operator+
String(const String & rhs); // constructeur de recopie nécessaire pour operator+
String(StringBuffer sb); // compatibilité Java
String(int bb, bool dummy); // pour la classe StringBuffer
~String();
char *val() {return sval;} // Pas sur de mettre sval publique
// Les fonctions ci-dessous imitent le String de Java
unsigned long length() { return strlen(sval); }
char charAt(int where);
void getChars(int sourceStart, int sourceEnd,
char target[], int targetStart);
char* toCharArray();
char* getBytes();
bool equals(String str2); // Voir aussi operator ==
bool equals(char *str2); // Voir aussi operator ==
bool equalsIgnoreCase(String str2);
bool regionMatches(int startIndex, String str2,
int str2StartIndex, int numChars);
bool regionMatches(bool ignoreCase, int startIndex,
String str2, int str2StartIndex, int numChars);
String toUpperCase();
String toLowerCase();
bool startsWith(String str2);
bool startsWith(char *str2);
bool endsWith(String str2);
bool endsWith(char *str2);
int compareTo(String str2);
int compareTo(char *str2);
int compareToIgnoreCase(String str2);
int compareToIgnoreCase(char *str2);
int indexOf(char ch, int startIndex = 0);
int indexOf(char *str2, int startIndex = 0);
int indexOf(String str2, int startIndex = 0);
int lastIndexOf(char ch, int startIndex = 0);
int lastIndexOf(char *str2, int startIndex = 0);
int lastIndexOf(String str2, int startIndex = 0);
String substring(int startIndex, int endIndex = 0);
String replace(char original, char replacement);
String replace(char *original, char *replacement);
String trim(); // Voir aussi trim() surcharge
String concat(String str2); // Voir aussi operator +
String concat(char *str2); // Voir aussi operator +
String reverse(); // Voir aussi reverse() surcharge
String deleteCharAt(int loc);
String deleteStr(int startIndex, int endIndex); // le "delete()" de Java
String valueOf(char ch)
{char aa[2]; aa[0]=ch; aa[1]=0; return String(aa);}
String valueOf(char chars[]){ return String(chars);}
String valueOf(char chars[], int startIndex, int numChars);
String valueOf(bool tf)
{if (tf) return String("true"); else return String("false");}
String valueOf(int num){ return String(num);}
String valueOf(long num){ return String(num);}
String valueOf(float num) {return String(num);}
String valueOf(double num) {return String(num);}
// Voir aussi la classe StringBuffer plus bas
// ---- Fin des fonctions à la Java -----
/////////////////////////////////////////////////////////////
// Liste des fonctions aditionnelles non présentes dans Java
/////////////////////////////////////////////////////////////
String ltrim();
void ltrim(bool dummy); // dummy pour avoir une signature differente
String rtrim();
void rtrim(bool dummy); // dummy pour avoir une signature differente
void chopall(char ch='\n'); // supprime les caractères 'ch' en fin
void chop(); // supprime un caractère en fin
void roundf(float input_val, short precision);
void decompose_float(long *integral, long *fraction);
void roundd(double input_val, short precision);
void decompose_double(long *integral, long *fraction);
void explode(char *seperator); // voir aussi token() et explode() surcharge
String *explode(int & strcount, char seperator = ' '); // voir aussi token()
void implode(char *glue);
void join(char *glue);
String repeat(char *input, unsigned int multiplier);
String tr(char *from, char *to); // translate characters
String center(int padlength, char padchar = ' ');
String space(int number = 0, char padchar = ' ');
String xrange(char start, char end);
String compress(char *list = " ");
String left(int slength = 0, char padchar = ' ');
String right(int slength = 0, char padchar = ' ');
String overlay(char *newstr, int start = 0, int slength = 0, char padchar = ' ');
String at(char *regx); // renvoie la première occurrence de regx
String before(char *regx); // renvoie la chaîne avant regx
String after(char *regx); // renvoie la chaîne apres regx
String mid(int startIndex = 0, int length = 0);
bool isNull();
bool isInteger();
bool isInteger(int pos);
bool isNumeric();
bool isNumeric(int pos);
bool isEmpty(); // idem que length() == 0
bool isUpperCase();
bool isUpperCase(int pos);
bool isLowerCase();
bool isLowerCase(int pos);
bool isWhiteSpace();
bool isWhiteSpace(int pos);
bool isBlackSpace();
bool isBlackSpace(int pos);
bool isAlpha();
bool isAlpha(int pos);
bool isAlphaNumeric();
bool isAlphaNumeric(int pos);
bool isPunct();
bool isPunct(int pos);
bool isPrintable();
bool isPrintable(int pos);
bool isHexDigit();
bool isHexDigit(int pos);
bool isCntrl();
bool isCntrl(int pos);
bool isGraph();
bool isGraph(int pos);
void clear();
int toInteger();
long parseLong();
double toDouble();
String token(char separator = ' '); // voir StringTokenizer, explode()
String crypt(char *original, char *salt);
String getline(FILE *infp = stdin); // voir aussi putline()
//String getline(fstream *infp = stdin); // voir aussi putline()
void putline(FILE *outfp = stdout); // voir aussi getline()
//void putline(fstream *outfp = stdout); // voir aussi getline()
void swap(String aa, String bb); // permute aa et bb
String *sort(String aa[]); // trie le tableau de chaînes
String sort(int startIndex = 0, int length = 0); // trie les caractères de la chaîne
int freq(char ch); // retourne le nombre d'occurrences distinctes, non superposees
void Format(const char *fmt, ...);
String replace (int startIndex, int endIndex, String str);
void substring(int startIndex, int endIndex, bool dummy);
void reverse(bool dummy); // dummy pour avoir une signature differente
String deleteCharAt(int loc, bool dummy);
String deleteStr(int startIndex, int endIndex, bool dummy);
void trim(bool dummy); // dummy pour avoir une signature differente
String insert(int index, String str2);
String insert(int index, String str2, bool dummy);
String insert(int index, char ch);
String insert(int index, char ch, bool dummy);
String insert(char *newstr, int start = 0, int length = 0, char padchar = ' ');
// requis par le StringBuffer de Java
void ensureCapacity(int capacity);
void setLength(int len);
void setCharAt(int where, char ch);
// requis par les classes Integer Long et Double de Java
int parseInt(String ss) {return ss.toInteger();}
int parseInt(char *ss)
{String tmpstr(ss); return tmpstr.toInteger();}
long parseLong(String ss) {return ss.parseLong();}
long parseLong(char *ss)
{String tmpstr(ss); return tmpstr.parseLong();}
float floatValue() {return (float) toDouble(); }
double doubleValue() {return toDouble(); }
///////////////////////////////////////////////
// Liste des fonctions dupliquées
///////////////////////////////////////////////
// char * c_str() // utilisez val()
// bool find(); // utilisez regionMatches()
// bool search(); // utilisez regionMatches()
// bool matches(); // utilisez regionMatches()
// int rindex(String str2, int startIndex = 0); utilisez lastIndexOf()
// String blanks(int slength); // utilisez repeat()
// String append(String str2); // utilisez concat() ou operator+
// String prepend(String str2); // utilisez operator+. Voir aussi append()
// String split(char seperator = ' '); // utilisez token()
bool contains(char *str2, int startIndex = 0); // utilisez indexOf()
// void empty(); utilisez is_empty()
// void vacuum(); utilisez clear()
// void erase(); utilisez clear()
// void zero(); utilisez clear()
// bool is_float(); utilisez is_numeric();
// bool is_decimal(); utilisez is_numeric();
// bool is_Digit(); utilisez is_numeric();
// float float_value(); utilisez toDouble();
// float tofloat(); utilisez toDouble();
// double double_value(); utilisez toDouble();
// double numeric_value(); utilisez toDouble();
// int int_value(); utilisez toInteger()
// int tonumber(); utilisez toInteger()
// String get(); utilisez substring() ou val() mais preferrez le substring de Java
// String getFrom(); utilisez substring() ou val() mais preferrez le substring de Java
// String head(int len); utilisez substring(0, len)
// String tail(int len); utilisez substring(length()-len, length())
// String cut(); utilisez deleteCharAt() ou deleteStr()
// String cutFrom(); utilisez deleteCharAt() ou deleteStr()
// String paste(); utilisez insert()
// String fill(); utilisez replace()
// char firstChar(); // utilisez substring(0, 1);
// char lastChar(); // utilisez substring(length()-1, length());
// String findNext(); utilisez token()
// begin(); iterator. utilisez operator [ii]
// end(); iterator. utilisez operator [ii]
// copy(); utilisez l'opérateur d'affectation, String aa = bb;
// clone(); utilisez l'opérateur d'affectation, String aa = bb;
// Tous les opérateurs ...
String operator+ (const String & rhs);
friend String operator+ (const String & lhs, const String & rhs);
String& operator+= (const String & rhs); // utiliser une référence va plus vite
String& operator= (const String & rhs); // utiliser une référence va plus vite
bool operator== (const String & rhs); // utiliser une référence va plus vite
bool operator== (const char *rhs);
bool operator!= (const String & rhs);
bool operator!= (const char *rhs);
char operator [] (unsigned long Index) const;
char& operator [] (unsigned long Index);
friend ostream & operator<< (ostream & Out, const String & str2);
friend istream & operator>> (istream & In, String & str2);
static list<String> explodeH; // tete de liste
protected:
char *sval; // Pas sûr de mettre sval publique
inline void verifyIndex(unsigned long index) const;
inline void verifyIndex(unsigned long index, char *aa) const;
void _str_cat(char bb[]);
void _str_cat(int bb);
void _str_cat(unsigned long bb);
void _str_cat(float bb);
private:
// Note : toutes les fonctions et variables privées ont des noms
// commencant par _ (souligne)
//static String *_global_String; // utilisé dans l'opérateur ajout
//inline void _free_glob(String **aa);
void _str_cpy(char bb[]);
void _str_cpy(int bb); // itoa
void _str_cpy(unsigned long bb);
void _str_cpy(float bb); // itof
bool _equalto(const String & rhs, bool type = false);
bool _equalto(const char *rhs, bool type = false);
String *_pString; // pointeur temporaire pour usage interne
inline void _allocpString();
inline void _reverse();
inline void _deleteCharAt(int loc);
inline void _deleteStr(int startIndex, int endIndex);
inline void _trim();
inline void _ltrim();
inline void _rtrim();
inline void _substring(int startIndex, int endIndex);
};
// Imite StringBuffer de Java
// Cette classe est prévue pour que le code Java soit portable en C++ en ne
// nécessitant que peu de changements
// Note : si vous codez en C++, N'utilisez PAS cette classe StringBuffer,
// elle n'est fournie que pour compiler du code écrit en Java copié/collé
// dans du code C++.
class StringBuffer: public String
{
public:
StringBuffer();
StringBuffer(int size);
StringBuffer(String str);
~StringBuffer();
int capacity() {return strlen(sval);}
StringBuffer append(String str2)
{ *this += str2; return *this;} // Voir aussi l'opérateur +
StringBuffer append(char *str2)
{ *this += str2; return *this;} // Voir aussi l'opérateur +
StringBuffer append(int bb)
{ *this += bb; return *this;} // Voir aussi l'opérateur +
StringBuffer append(unsigned long bb)
{ *this += bb; return *this;} // Voir aussi l'opérateur +
StringBuffer append(float bb)
{ *this += bb; return *this;} // Voir aussi l'opérateur +
StringBuffer append(double bb)
{ *this += bb; return *this;} // Voir aussi l'opérateur +
StringBuffer insert(int index, String str2)
{ return String::insert(index, str2, true);}
StringBuffer insert(int index, char ch)
{ return String::insert(index, ch, true);}
StringBuffer reverse()
{ String::reverse(true); return *this;}
// le "delete()"de Java. On ne peut pas utiliser le nom delete en C++
StringBuffer deleteStr(int startIndex, int endIndex)
{ String::deleteStr(startIndex, endIndex, true); return *this;}
StringBuffer deleteCharAt(int loc)
{ String::deleteCharAt(loc, true); return *this;}
StringBuffer substring(int startIndex, int endIndex = 0)
{ String::substring(startIndex, endIndex, true); return *this;}
};
static String Integer("0"); // Integer.parseInt(String) de Java
static String Long("0"); // Long.parseLong(String) de Java
// Imite la classe Float et Float.floatValue() de Java
// Est fournie pour compiler du code Java en C++.
class Float: public String
{
public:
Float(String str);
Float valueOf(String str2) {return Float(str2);}
float floatValue() {return (float) toDouble(); }
};
// Imite la classe Double de Java et Double.doubleValue()
// Est fournie pour compiler du code Java en C++.
class Double: public String
{
public:
Double(String str);
Double valueOf(String str2) {return Double(str2);}
double doubleValue() {return toDouble(); }
};
// Imite la classe StringTokenizer de Java
// Fournie pour compiler du code Java en C++ et vice-versa
class StringTokenizer: public String
{
public:
StringTokenizer(String str);
StringTokenizer(String str, String delimiters);
StringTokenizer(String str, String delimiters, bool dflag);
~StringTokenizer();
int countTokens();
bool hasMoreElements();
bool hasMoreTokens();
String nextElement(); // en Java retourne un 'Object'
String nextToken();
String nextToken(String delimiters);
private:
int _current_position; // position courante dans la chaîne
int _total_tokens;
int _remaining_tokens;
char * _listofdl; // liste de delimiteurs
char * _workstr; // chaîne temporaire
char * _origstr; // chaîne originalement passée
bool _dflag; // indicateur de delimiteur
inline void _prepworkstr(char *delimiters = NULL);
};
// Imite la classe StringReader de Java
// Fournie pour compiler du code Java en C++
class StringReader: public String
{
public:
StringReader(String str);
void close() {} // ferme le flux
void mark(int readAheadLimit);
bool markSupported() {return true;} // indique si le flux supporte l'opération mark(), il le fait
int read();
int read(char cbuf[], int offset, int length);
bool ready() {return true;} // indique si le flux est prêt à être lu
void reset();
long skip(long ii);
private:
unsigned long _curpos;
unsigned long _mark_pos;
};
// Imite la classe StringWriter de Java
// fournie pour compiler du code Java en C++
class StringWriter: public String
{
public:
StringWriter();
StringWriter(int bufferSize);
void close() {clear();}
void flush() {clear();}
StringBuffer getBuffer() {return (StringBuffer) *this;}
String toString() {return (String) *this;}
void write(int);
void write(String);
void write(char *str1);
void write(char str1[], int startIndex, int endIndex);
void write(String str1, int startIndex, int endIndex);
};
// Les variables globales sont définies dans String.cpp
#endif // __STRING_H_
Hosting by: Hurra Communications GmbH
Generated: 2007-01-26 18:01:30