Type de donnée personnalisé : string

Télécharger le projet
Commenter

Description

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);


        
  • 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

Conclusion :


J'aurais besoin d'aide pour la fonction LoadFile --- J'ai toujour besoin d'aide pour la fonction LoadFile
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_Light Angel)