C'est une classe pas tout à fait terminé mais bon, elle est fonctionnelle est c'est déja sa ...
J'ai ecrit le source dans un fichier .hpp (je sais, il ne faut pas mêttre de fonction dans les headers, mais j'avais la flemme de faire un fichier cpp à coté, bon bref, dans le fichier .hpp, j'ai rajouté un teste dans le préprocésseur pour éviter de compiler le fichier plusieurs fois (si on l'inclut plusieurs fois) :
#ifndef STRING
#define STRING NULL
...
...
...
#endif
Source / Exemple :
// Ne compile le fichier qu'une seul fois --------------------------------------
#ifndef STRING
#define STRING NULL
// Directive #include ----------------------------------------------------------
#include <stdio.h> // Gère la structure FILE
#include <stdlib.h> // Gère system(const char *)
#include <string> // Gère les chaine de caractères
#include <fstream> // Gère les fichiers
#include <iostream> // Gère les E/S
// Utilise les standard C++ ----------------------------------------------------
using namespace std;
// Constantes ------------------------------------------------------------------
#define LINE '\n' // Saut de ligne
#define TAB '\t' // Tabulation
#define BEEP '\a' // Produit un "beep"
#define NULLT '\0' // Null terminal
// Déclaration de la classe ---------------------------------------------------
class String
{
// Membres privés ----------------------------------------------------------
private:
char *Char; // Chaine principale
int MemSize; // Taille de la mémoire
int Len; // Nombre de caractère de *pChaine
char *NewMemory(int Lenght); // Fonction utilisé par le constructeur
// Membres publiques -------------------------------------------------------
public :
// Constructeurs --------------------------------------------------------------
String(const char *Str = "");
String(const String & Source);
String(char strString);
String(int Lengh);
// Destructeur -----------------------------------------------------------------
~String();
// Opérateurs surchargé ----------------------------------------------------
// Opérateurs mathématiques ----------------------------------------------
char operator [] (int Index) const;
String & operator = (const String & Source);
friend String operator + (const String & S1, const String & S2);
friend String operator & (const String & S1, const String & S2);
// Opérateurs de comparaisons ----------------------------------
friend int operator != (const String & S1, const String & S2);
friend int operator == (const String & S1, const String & S2);
friend int operator < (const String & S1, const String & S2);
friend int operator > (const String & S1, const String & S2);
friend int operator <= (const String & S1, const String & S2);
friend int operator >= (const String & S1, const String & S2);
//Opérateurs d'E/S -------------------------------------------------
friend ostream & operator << (ostream & Flux, const String & Source);
friend istream & operator >> (istream & Flux, String & Source);
// Méthodes ----------------------------------------------------------------
bool SaveFile(const char *File); // Enregistre Char dans un fichier
void LoadFile(const char *File); // Récupère les données d'un fichier
// Méthodes utiles ---------------------------------------------------------
inline int Lenght(void); // Retourne this->Len
inline int Asc(int Index); // Retourne le code ASCII
inline char *ToString(void) const; // Convertit un String en char
String Left(int Lenght); // Retourne les X caractère de gauche
String Right(int Lenght); // Retourne les X caractère de droite
String Mid(int Start, int Lengh); // Retourne les X caractère de Start
};
// Fonction membres de string --------------------------------------------------
// Constructeurs surchargés ----------------------------------------------------
String::String(const char *str)
{
// Défint Char
Len = strlen(str);
Char = NewMemory(Len);
// Copie Chn dans Char
strcpy(Char, str);
}
String::String(int Lengh)
{
// Nombre de caractère = 0
Len = 0;
// Alloue dynamiquement Char
Char = NewMemory(Lengh);
Char[0] = NULLT;
}
String::String(const String & Source)
{
// Définit Char selon une référence
Len = Source.Len;
Char = NewMemory(Source.Len);
// Copie Char de la référence dans Char
strcpy(Char, Source.Char);
}
String::String(char String)
{
// Définit les membres
Len = 1;
Char = NewMemory(Len);
// Ajoute le null terminal
}
// Destructeur -----------------------------------------------------------------
String::~String()
{
// Désaloue Char
if(Char) delete [] Char;
// Désactive le pointeur
Char = NULL;
}
// Fonction NewMemory ----------------------------------------------------------
char *String::NewMemory(int Lengh)
{
if (Lengh < 0)
{
// Quitte la fonction
return NULL;
}
// Garde de la place pour le nul terminal
MemSize = Lengh + 1;
// Alloue dynamiquemenr un pointeur vers char
char *P = new char[MemSize];
// Teste si l'allocation à réussi
if (! P)
{
// Quitte la fonction
return NULL;
}
// Retourne l'addresse de P
return P;
}
// Fonction ToString -----------------------------------------------------------
char *String::ToString(void) const
{
// Retourne Char
return Char;
}
// Fonction ASC ----------------------------------------------------------------
int String::Asc(int Index)
{
// Utilise l'operateur [] précédement surchargé
int intAscii = Char[Index];
return intAscii;
}
// Fonction Left ---------------------------------------------------------------
String String::Left(int Lenght)
{
// Teste si Lenght est > a la taille de la chaine
if (Lenght > Len)
{
// Retourne une valeur bidon
String Error("Erreur : Lenght plus grand que strlen(Char)");
return Error;
}
// Crée deux object String
String S1(Char);
String S2(Lenght);
// Récupère les caractère l'un apres l'autre
for (int intI = 0; intI < Lenght; intI++)
S2 = S2 & S1[intI];
// Retourne l'objet S2
return S2;
}
// Fonction Right --------------------------------------------------------------
String String::Right(int Lenght)
{
// Teste si Lenght > Len
if (Lenght > Len)
{
// Retourne une valeur bidon
String strError("Erreur : Lenght lus grand que strlen(Char)");
return strError;
}
// Crée deux object String
String S1(Char);
String S2(Lenght);
// Récupère les caractère l'un après l'autre
for (int intI = 0; intI < Lenght; intI++)
S2 = S1[Len - intI - 1] & S2;
// Retourne l'objet S2
return S2;
}
// Fonction Mid ----------------------------------------------------------------
String String::Mid(int Start, int Lenght)
{
// Teste si Start est < ou > au extrémité
if (Start < 0 || Start > Len)
{
// Retourne un message d'erreur
String strError("Start < à 0 ou > à Lenght()");
return strError;
}
// Teste si Lenght <= 0
if (Lenght <= 0)
{
// Retourne une chaine nulle
String strNull(NULL);
return strNull;
}
// Crée deux object String
String S1(Char);
String S2(Lenght);
// Récupère les caractère l'un apres l'autre
for (int intI = Start; intI < Lenght; intI++)
S2 = S2 & S1[intI];
// Retourne l'objet S2
return S2;
}
// Fonction Lenght -------------------------------------------------------------
int String::Lenght(void)
{
// Retourne Len
return this->Len;
}
// Fonction SaveFile -----------------------------------------------------------
bool String::SaveFile(const char *File)
{
// Enregistre Char dans un fichiers
ofstream fout(File, ios::trunc);
// Teste l'ouverture du fichier
if (! fout)
return false;
// Imprime Char dans le fichier
fout << Char;
// Ferme le fichier
fout.close();
// Retourne vrai
return true;
}
// Fonction LoadFile -----------------------------------------------------------
void String::LoadFile(const char *File)
{
}
// Opérateurs surchargé --------------------------------------------------------
// Opérateur d'indexation ------------------------------------------------------
char String::operator [](int Index) const
{
// Teste Index
if (Index < 0 || Index >= Len)
{
// Quitte la fonction
return NULL;
}
// Retourne un caractère
return Char[Index];
}
// Opérateur d'affectation -----------------------------------------------------
String & String::operator =(const String & Source)
{
// Teste si la référence est valable
if (this != &Source)
{
if ((MemSize - 1) < Source.Len)
{
// Supprime Char et le réalloue dynamiquement
delete [] Char;
Char = NewMemory(Source.Len);
}
// Copie la chaine de la référence dans Char
strcpy(Char, Source.Char);
Len = Source.Len;
}
// Renvoi la valeur de l'adresse d'un pointeur vers String
return *this;
}
// Opérateur d'addition --------------------------------------------------------
String operator +(const String & S1, const String & S2)
{
// Crée des objet String temporaires
String Temp(S1.Len + S2.Len);
strcat(strcpy(Temp.Char, S1.Char), S2.Char);
Temp.Len = strlen(Temp.Char);
// Retourne un objet String : Temp
return Temp;
}
// Autre opérateur d'addition --------------------------------------------------
String operator &(const String & S1, const String & S2)
{
// Crée des objet String temporaires
String Temp(S1.Len + S2.Len);
strcat(strcpy(Temp.Char, S1.Char), S2.Char);
Temp.Len = strlen(Temp.Char);
// Retourne un objet String : Temp
return Temp;
}
// Opérateur d'inégalité -------------------------------------------------------
int operator !=(const String & S1, const String & S2)
{
// Retourne le résultat de strcmp
return strcmp(S1.Char, S2.Char);
}
// Opérateur d'égalité ---------------------------------------------------------
int operator ==(const String & S1, const String & S2)
{
// Retourne strcmp
return(strcmp(S1.Char, S2.Char));
}
// Opérateur supérieur ---------------------------------------------------------
int operator >(const String & S1, const String & S2)
{
// Retourne le résultat de strcmp
return (strcmp(S1.Char, S2.Char) > 0);
}
// Opérateur inferieur ---------------------------------------------------------
int operator <(const String & S1, const String & S2)
{
// Retourne le résultat de strcmp
return (strcmp(S1.Char, S2.Char) < 0);
}
// Opérateur superieur ou égal -------------------------------------------------
int operator >=(const String & S1, const String & S2)
{
// Retourne une comparaison avec <
return (! (S1 < S2));
}
// Opérateur inferieur ou égal -------------------------------------------------
int operator <=(const String & S1, const String & S2)
{
// Retourne une comparaison avec >
return (! (S1 > S2));
}
// Opérateur de sortie << ------------------------------------------------------
ostream & operator << (ostream & Flux, const String & Source)
{
// Retourne le Flot
return Flux << Source.Char;
}
// Opérateur d'entré >> --------------------------------------------------------
istream & operator >> (istream & Flux, String & Source)
{
// Lit Source par morceau
const int MaxSize = 5;
char c;
// Vide Source
Source = "";
// Crée un objetString Temporaire
String Temp(MaxSize);
Flux.get(c);
// Boucle jusqu'a ce que c = LINE
while (c != LINE)
{
// Continue
Flux.putback(c);
Flux.get(Temp.Char, Temp.MemSize - 1, LINE);
Temp.Len = strlen(Temp.Char);
Source = Source + Temp;
Flux.get(c);
}
// Reourne le Flot de donnée
return Flux;
}
// Fin de la directive #ifndef -------------------------------------------------
#endif
Conclusion :
J'aurais besoin d'aide pour la fonction LoadFile --- J'ai toujour besoin d'aide pour la fonction LoadFile
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.