TYPE DE DONNÉE PERSONNALISÉ : STRING

// 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);
    *Char = String;
    // Ajoute le null terminal
    *(Char + 1) = NULLT;
}
// 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