CodeS-SourceS est hébergé par Frontier.fr

Cliquez ici pour mettre ce site au démarrage de votre navigateur

AccueilCodesTutorielsForumsEmploiLivresGuide achatConnexion

begin process at 2009 07 05 12:16:03

SILVERLIGHT 3 : COMMUNICATION ET MULTICAST par KooKiz

[PERSO] DéCOUVERTES ESTIVALES : LINUX (PART I) par FREMYCOMPANY

[REFACTORING] ANALYSER VOS EXCEPTIONS AVEC RESHARPER EXCEPTIONAL par tja

SHAREPOINT 2007 : PATTERNS & PRACTICES SHAREPOINT GUIDANCE par phil

DEMANDE D'AIDE SUR C++BUILDER(SEGMENTATION SEQUENCE VIDEO) par fcbomar2007

RE : TRAITEMENT D'UN FICHIER par dan34

RE : TRAITEMENT D'UN FICHIER par boualiasma

TRAITEMENT D'UN FICHIER par boualiasma

+ de logiciels à télécharger

1 464 611 membres
114 nouveaux aujourd'hui
15 045 membres club

Trouver une ressource

Trouvez une ressource parmi 40 096 codes, 1 302 943 messages d'aide etc...

Recherche: dans [ Dernières recherches ]

Filtre:Tous les codes.NET uniquementExclure .NET

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

CHARBUFFER

Information sur la source

Catégorie :Chaîne de caractères Niveau : Débutant Date de création : 13/10/2004 Date de mise à jour : 14/10/2004 18:48:22 Vu : 2 384

Auteur : thiosyiasar

Ecrire un message privé

Ce membre participe au partage de revenus publicitaires

Note :
Aucune note

Commentaire sur cette source (16)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

Je sais que je réinvente la roue mais étant débutant en c++ je soumets ma première source aux commentaires.
Son but est aussi pédagogique pour les débutants qu'inutile pour les autres.

Cette classe permet de gérer un tampon de char géré par HeapAlloc(), HeapRealloc(), et HeapFree()

Les méthodes sont les suivantes :

// Constructeur permettant de spécifier la taille initiale du tampon
XCharBuffer(const unsigned int p_iSize);

// GESTION DE LA TAILLE
bool setBufferSize(const unsigned int p_size);    // Défini la taille du tampon
bool pack();    // Ajuste la taille du tampon au contenu
unsigned int getValueSize();    // Retourne la taille de la chaine contenu (sans le \0)
unsigned int getBufferSize();    // Retourne la taille du tampon

// GESTION DU CONTENU
void clear();    // Efface le contenu du tampon
void append(const char* p_pszValue);    // Ajoute une chaine
char* toCharArray();    // Retourne le contenu (char*)

Cette peut être spécialisée car les méthodes de gestion du tampon sont protected

Source

// XCharBuffer.h
#include "Windows.h"
class XCharBuffer
{
public:
// GESTION DE L'INSTANCE
// Construteurs
XCharBuffer(const unsigned int p_iSize);
// Déstructeur
virtual ~XCharBuffer();
// GESTION DE LA TAILLE
// Défini la taille du tampon
bool setBufferSize(const unsigned int p_size);
// Ajuste la taille du tampon au contenu
bool pack();
// Retourne la taille de la chaine contenu (sans le \0)
unsigned int getValueSize();
// Retourne la taille du tampon
unsigned int getBufferSize();
// GESTION DU CONTENU
// Efface le contenu du tampon
void clear();
// Ajoute une chaine
void append(const char* p_pszValue);
void append(const unsigned char* p_pszValue);
// Retourne le contenu (char*)
char* toCharArray();
// Retourne le contenu (BSTR)
//const BSTR* toCharArray();
protected:
HANDLE m_hHeapHandle; // Handle du Tas contenant le buffer
char *m_pszBuffer; // Tampon de stockage
char *m_pBufferPos; // Pointeur sur le prochain caratère à ecrire
char *m_pBufferPosMax; // Pointeur sur le prochain caratère à ecrire
unsigned int m_iBufferSize; // Taille allouée au tampon
unsigned int m_iValueSize; // Taille de la valeur contenue
// Crée ou agrandi le buffer si necessaire pour y stocker (p_iSize) nouveaux caractères
inline bool increaseBuffer(const unsigned int p_iSize);
// Redéfinie la taille du tampon existant à (p_iSize) caractères
inline bool resizeBuffer(const unsigned int p_iSize);
// Retourne la taille de la chaine sans le \0
inline unsigned int getLength(const char* p_pszValue);
// Copie les (p_iSize) caractères du buffer (source) vers le buffer (target)
inline void copyBuffer(const char* p_pszSrcValue, char* p_pszTrgValue, unsigned int p_iSize);
};
__________________________________________________________________________________________________
// XCharBuffer.cpp
#include "XCharBuffer.h"
/***********************************************************************
*
* INTERFACTION PUBLIQUE
*
***********************************************************************/
/****************************************************************
* GESTION DE L'INSTANCE
****************************************************************/
// Construteur
XCharBuffer::XCharBuffer(const unsigned int p_iSize)
{
// Définition du tas à utiliser
this->m_hHeapHandle = GetProcessHeap();
this->m_pszBuffer = NULL; // Tampon de stockage
this->m_pBufferPos = NULL; // Pointeur sur le prochain caratère à ecrire
this->m_pBufferPosMax = NULL; // Valeur maxi du pointeur
this->m_iBufferSize = 0; // Taille allouée au tampon
this->m_iValueSize = 0; // Taille de la valeur contenue
// Mise à jour de la taille du tampon
this->increaseBuffer(p_iSize);
}
// Déstructeur
XCharBuffer::~XCharBuffer()
{
// Destruction du tampon si créé
if (this->m_pszBuffer)
if (!HeapFree(this->m_hHeapHandle, 0, this->m_pszBuffer))
{
;// Ya Erreur ! ;
}
}
/****************************************************************
* GESTION DE LA TAILLE
****************************************************************/
// Redefini la taille de (p_size) caratère
bool XCharBuffer::setBufferSize(const unsigned int p_size)
{
return this->resizeBuffer(p_size);
}
// Ajuste la taille du tampon au contenu
bool XCharBuffer::pack()
{
return this->resizeBuffer(this->m_iValueSize);
}
// Retourne la taille de la chaine contenu (sans le \0)
unsigned int XCharBuffer::getValueSize()
{
return this->m_iValueSize;
}
// Retourne la taille du tampon
unsigned int XCharBuffer::getBufferSize()
{
return this->m_iBufferSize;
}
/****************************************************************
* GESTION DU CONTENU
****************************************************************/
// Efface le contenu du tampon
void XCharBuffer::clear()
{
// Mise à 0 de tous les caractères
for (char* pChar = this->m_pszBuffer; pChar < this->m_pBufferPosMax; pChar++)
*pChar = 0;
// Positionement sur le premier caractère
this->m_pBufferPos = this->m_pszBuffer;
// Réajustement de la taille de la valeur
this->m_iValueSize = 0;
}
// Ajoute une chaine
void XCharBuffer::append(const char* p_pszValue)
{
// Lecture du nombre de caractère à ajouter
unsigned int iSize = this->getLength(p_pszValue);
// Agrandissement du tampon
if (this->increaseBuffer(iSize))
{
// Copie de la nouvelle chaine
this->copyBuffer(p_pszValue, this->m_pBufferPos, iSize);
// Positionement sur le prochain caractère
this->m_pBufferPos += iSize;
// Mise à jour de la taille de la valeur
this->m_iValueSize += iSize;
}
}
// Ajoute une chaine
void XCharBuffer::append(const unsigned char* p_pszValue)
{
this->append((const char*)p_pszValue);
}
// Retourne le contenu (char*)
char* XCharBuffer::toCharArray()
{
*this->m_pBufferPos = 0;
return this->m_pszBuffer;
}
/*****************************************************************
*
* METHODES PROTEGEES
*
*****************************************************************/
// Crée ou agrandi le buffer si necessaire pour y stocker (p_iSize) nouveaux caractères
inline bool XCharBuffer::increaseBuffer(const unsigned int p_iSize)
{
// Si aucune taille nécessaire
if (p_iSize == 0)
return false;
// Si pas de mémoire allouée
if (!this->m_pBufferPos)
{
// Allocation pour le tampon (+ 1 pour le \0)
this->m_pszBuffer = (char*)HeapAlloc(this->m_hHeapHandle, HEAP_ZERO_MEMORY, p_iSize + 1);
if (!this->m_pszBuffer)
{
return false; // Ya Erreur
}
// Initialisation du tampon
this->m_pBufferPos = this->m_pszBuffer; // Positionement sur le premier caractère
this->m_pBufferPosMax = this->m_pBufferPos + p_iSize; // Définition du dernier caractère
this->m_iBufferSize = (unsigned int)p_iSize; // Définition de la taille du tampon
}
// Si mémoire déja allouée
else
{
// Calcul de l'espace restant
unsigned int iFreeSize = this->m_pBufferPosMax - this->m_pBufferPos;
// Si pas suffisement d'espace dans le tampon
if (iFreeSize < p_iSize)
{
// Calcul de l'espace nécessaire
unsigned int iRequiredSize = this->m_iBufferSize + (p_iSize - iFreeSize);
// Redimensionnement du tampon
if (!this->resizeBuffer(iRequiredSize))
{
return false; // Ya Erreur
}
}
}
return true;
}
// Redéfinie la taille du tampon existant à (p_iSize) caractères
inline bool XCharBuffer::resizeBuffer(const unsigned int p_iSize)
{
// Si pas de mémoire allouée
if (!this->m_pBufferPos)
return false; // Ya Erreur
// Reallocation du tampon (+1 pour le \0)
char* pNewBuffer = (char*)HeapReAlloc(this->m_hHeapHandle, HEAP_ZERO_MEMORY, this->m_pszBuffer, p_iSize + 1);
// Vérification si alloué
if (pNewBuffer)
{
this->m_pszBuffer = pNewBuffer; // Mise à jour de l'adresse du tampon
this->m_pBufferPos = this->m_pszBuffer + m_iBufferSize; // Positionement sur le prochain caractère
this->m_pBufferPosMax = this->m_pBufferPos + p_iSize; // Définition du dernier caractère
this->m_iBufferSize = p_iSize; // Définition de la taille du tampon
}
else
{
return false; // Ya Erreur
}
return true;
}
// Retourne la taille de la chaine sans le \0
inline unsigned int XCharBuffer::getLength(const char* p_pszValue)
{
unsigned int iSize = 0;
const char* pszPos = p_pszValue;
while(*pszPos++)
iSize++;
return iSize;
}
// Copie les (p_iSize) caractères du buffer (source) vers le buffer (target)
inline void XCharBuffer::copyBuffer(const char* p_pszSrcValue, char* p_pszTrgValue, unsigned int p_iSize)
{
const char* pSrc = p_pszSrcValue;
char* pTrg = p_pszTrgValue;
for (unsigned int i = 0; i < p_iSize; i++)
*pTrg++ = *pSrc++;
}

//    XCharBuffer.h

#include "Windows.h"

class XCharBuffer  
{
	public:

		// GESTION DE L'INSTANCE

		// Construteurs
		XCharBuffer(const unsigned int p_iSize);

		// Déstructeur
		virtual ~XCharBuffer();


		// GESTION DE LA TAILLE

		// Défini la taille du tampon
		bool setBufferSize(const unsigned int p_size);
		
		// Ajuste la taille du tampon au contenu
		bool pack();

		// Retourne la taille de la chaine contenu (sans le \0)
		unsigned int getValueSize();

		// Retourne la taille du tampon
		unsigned int getBufferSize();

		
		// GESTION DU CONTENU

		// Efface le contenu du tampon
		void clear();
	
		// Ajoute une chaine
		void append(const char* p_pszValue);
		void append(const unsigned char* p_pszValue);
		
		// Retourne le contenu (char*)
		char* toCharArray();

		// Retourne le contenu (BSTR)
		//const BSTR* toCharArray();

	protected:

		HANDLE			 m_hHeapHandle;		// Handle du Tas contenant le buffer

		char			*m_pszBuffer;		// Tampon de stockage
		char			*m_pBufferPos;		// Pointeur sur le prochain caratère à ecrire
		char			*m_pBufferPosMax;	// Pointeur sur le prochain caratère à ecrire
		unsigned int	 m_iBufferSize;		// Taille allouée au tampon 
		unsigned int	 m_iValueSize;		// Taille de la valeur contenue


		// Crée ou agrandi le buffer si necessaire pour y stocker (p_iSize) nouveaux caractères
		inline bool increaseBuffer(const unsigned int p_iSize);

		// Redéfinie la taille du tampon existant à (p_iSize) caractères
		inline bool resizeBuffer(const unsigned int p_iSize);

		// Retourne la taille de la chaine sans le \0
		inline unsigned int getLength(const char* p_pszValue);
		
		// Copie les (p_iSize) caractères du buffer (source) vers le buffer (target)
		inline void copyBuffer(const char* p_pszSrcValue, char* p_pszTrgValue, unsigned int p_iSize);
	
};
__________________________________________________________________________________________________
// XCharBuffer.cpp 

#include "XCharBuffer.h"


/***********************************************************************
 *
 *	INTERFACTION PUBLIQUE
 *
 ***********************************************************************/

/****************************************************************
 *		GESTION DE L'INSTANCE
 ****************************************************************/

// Construteur
XCharBuffer::XCharBuffer(const unsigned int p_iSize)
{
	// Définition du tas à utiliser
	this->m_hHeapHandle		= GetProcessHeap();

	this->m_pszBuffer		= NULL;	// Tampon de stockage
	this->m_pBufferPos		= NULL;	// Pointeur sur le prochain caratère à ecrire
	this->m_pBufferPosMax	= NULL;	// Valeur maxi du pointeur
	this->m_iBufferSize		= 0;	// Taille allouée au tampon 
	this->m_iValueSize		= 0;	// Taille de la valeur contenue

	// Mise à jour de la taille du tampon
	this->increaseBuffer(p_iSize);
}

// Déstructeur
XCharBuffer::~XCharBuffer()
{
	// Destruction du tampon si créé
	if (this->m_pszBuffer)
		if (!HeapFree(this->m_hHeapHandle, 0, this->m_pszBuffer))
		{
			;// Ya Erreur !	;
		}
}

/****************************************************************
 *		GESTION DE LA TAILLE
 ****************************************************************/

// Redefini la taille de (p_size) caratère
bool XCharBuffer::setBufferSize(const unsigned int p_size)
{
	return this->resizeBuffer(p_size);
}

// Ajuste la taille du tampon au contenu
bool XCharBuffer::pack()
{
	return this->resizeBuffer(this->m_iValueSize);
}

// Retourne la taille de la chaine contenu (sans le \0)
unsigned int XCharBuffer::getValueSize()
{
	return this->m_iValueSize;
}

// Retourne la taille du tampon
unsigned int XCharBuffer::getBufferSize()
{
	return this->m_iBufferSize;
}

/****************************************************************
 *		GESTION DU CONTENU
 ****************************************************************/

// Efface le contenu du tampon
void XCharBuffer::clear()
{
	// Mise à 0 de tous les caractères
	for (char* pChar = this->m_pszBuffer; pChar < this->m_pBufferPosMax; pChar++)
		*pChar = 0;
	// Positionement sur le premier caractère
	this->m_pBufferPos = this->m_pszBuffer;
	// Réajustement de la taille de la valeur
	this->m_iValueSize = 0;
}

// Ajoute une chaine
void XCharBuffer::append(const char* p_pszValue)
{
	// Lecture du nombre de caractère à ajouter
	unsigned int iSize = this->getLength(p_pszValue);
	// Agrandissement du tampon
	if (this->increaseBuffer(iSize))
	{
		// Copie de la nouvelle chaine
		this->copyBuffer(p_pszValue, this->m_pBufferPos, iSize);
		// Positionement sur le prochain caractère
		this->m_pBufferPos += iSize;
		// Mise à jour de la taille de la valeur
		this->m_iValueSize += iSize;
	}
}

// Ajoute une chaine
void XCharBuffer::append(const unsigned char* p_pszValue)
{
	this->append((const char*)p_pszValue);
}

// Retourne le contenu (char*)
char* XCharBuffer::toCharArray()
{
	*this->m_pBufferPos = 0;
	return this->m_pszBuffer;
}


/*****************************************************************
 *
 *	METHODES PROTEGEES
 *
 *****************************************************************/



// Crée ou agrandi le buffer si necessaire pour y stocker (p_iSize) nouveaux caractères
inline bool XCharBuffer::increaseBuffer(const unsigned int p_iSize)
{
	// Si aucune taille nécessaire
	if (p_iSize == 0)
		return false;

	// Si pas de mémoire allouée
	if (!this->m_pBufferPos)
	{	
		// Allocation pour le tampon (+ 1 pour le \0)
		this->m_pszBuffer = (char*)HeapAlloc(this->m_hHeapHandle, HEAP_ZERO_MEMORY, p_iSize + 1);

		if (!this->m_pszBuffer)
		{
			return false; // Ya Erreur
		}

		// Initialisation du tampon
		this->m_pBufferPos = this->m_pszBuffer;					// Positionement sur le premier caractère
		this->m_pBufferPosMax = this->m_pBufferPos + p_iSize;	// Définition du dernier caractère
		this->m_iBufferSize = (unsigned int)p_iSize;			// Définition de la taille du tampon
	}

	// Si mémoire déja allouée
	else
	{	
		// Calcul de l'espace restant
		unsigned int iFreeSize = this->m_pBufferPosMax - this->m_pBufferPos;
		
		// Si pas suffisement d'espace dans le tampon
		if (iFreeSize < p_iSize)
		{
			// Calcul de l'espace nécessaire
			unsigned int iRequiredSize = this->m_iBufferSize + (p_iSize - iFreeSize); 
			
			// Redimensionnement du tampon
			if (!this->resizeBuffer(iRequiredSize))
			{
				return false; // Ya Erreur
			}

		}

	}
	return true;

}

// Redéfinie la taille du tampon existant à (p_iSize) caractères
inline bool XCharBuffer::resizeBuffer(const unsigned int p_iSize)
{

	// Si pas de mémoire allouée
	if (!this->m_pBufferPos)
		return false; // Ya Erreur

	// Reallocation du tampon (+1 pour le \0)
	char* pNewBuffer = (char*)HeapReAlloc(this->m_hHeapHandle, HEAP_ZERO_MEMORY, this->m_pszBuffer, p_iSize + 1);
	
	// Vérification si alloué
	if (pNewBuffer)
	{
		this->m_pszBuffer = pNewBuffer;								// Mise à jour de l'adresse du tampon
		this->m_pBufferPos = this->m_pszBuffer + m_iBufferSize;		// Positionement sur le prochain caractère
		this->m_pBufferPosMax = this->m_pBufferPos + p_iSize;		// Définition du dernier caractère
		this->m_iBufferSize = p_iSize;								// Définition de la taille du tampon
	}
	else
	{
		return false; // Ya Erreur
	}

	return true;
		
}

// Retourne la taille de la chaine sans le \0
inline unsigned int XCharBuffer::getLength(const char* p_pszValue)
{
	unsigned int iSize = 0;
	const char* pszPos = p_pszValue;
	while(*pszPos++)
		iSize++;
	return iSize;
}

// Copie les (p_iSize) caractères du buffer (source) vers le buffer (target)
inline void XCharBuffer::copyBuffer(const char* p_pszSrcValue, char* p_pszTrgValue, unsigned int p_iSize)
{
	const char* pSrc = p_pszSrcValue;
	char* pTrg = p_pszTrgValue;
	for (unsigned int i = 0; i < p_iSize; i++)
		*pTrg++ = *pSrc++;
}

Conclusion

Voici la procédure que j'utilise pour les test

En testant différentes tailles lors de l'initialisation (dans le constructeur)
il m'arrive que le return 0 du main() génére une exception avec le message suivant
Free Heap block 1345b0 modified at 1345e4 after it was freed
Je cherche mais je n'ai toujours pas compris pourkoi ??????
Je sais qu'avait la valeur 100, le code suivant termine en erreur

int main(int argc, char* argv[])
{
//XCharBuffer *poBuffer = new XCharBuffer(0);
XCharBuffer *poBuffer = new XCharBuffer(32);

poBuffer->append("toto");
std::cout << poBuffer->toCharArray() << " - "
  << (int)poBuffer->getValueSize() << " - "
  << (int)poBuffer->getBufferSize() << std::endl;
poBuffer->append(" et pis tata");
std::cout << poBuffer->toCharArray() << " - "
  << (int)poBuffer->getValueSize() << " - "
  << (int)poBuffer->getBufferSize() << std::endl;
poBuffer->pack();
std::cout << poBuffer->toCharArray() << " - "
  << (int)poBuffer->getValueSize() << " - "
  << (int)poBuffer->getBufferSize() << std::endl;
delete poBuffer;
return 0;
}

Historique

14 octobre 2004 12:23:13 :: Correction du destructeur (voir le commentaire de brunews) Malheureusement cela ne résoud pas le bug qui persiste toujours..... ! (voir capture d'écran)
14 octobre 2004 15:09:45 :: Correction du destructeur
14 octobre 2004 18:48:22 :: correction des includes

Sources de la même categorie

ANALYSEUR SYNTAXIQUEV(0.1) par kohan95

DISTANCE DE JARO-WINKLER par PoulpHunter

SIMPLE FONCTION TOKENIZE par spidermario

ANALYSEUR LEXICAL DU LANGAGE PASCAL par zakizaki7

ITOA FAIT MASION: COVERSION ENTIER 32 BIT NON SIGNE VERS CHA... par xtremejames183

Toutes les sources de la catégorie Chaîne de caractères

Commentaires et avis

Commentaire de cosmobob le 13/10/2004 20:05:32

salut ;)
bon juste une remarque pas immensément importante... à l'interieur d'une méthode de classe, si tu fais référence a un champ de cette classe ou a une autre methode, t'es pas obligé de mettre this-> devant. this est surtout utile quand une méthode renvoie un pointeur (ou une reference) vers l'objet considéré.
a++

Commentaire de leprov le 13/10/2004 21:00:14

ou pour la réécriture d'un operateur d'affectation pour eviter l'autoaffectation dont le resultat est plus que douteux.....ou encore pour appeler une autre methode de cette classe avec cet objet

Commentaire de djl le 13/10/2004 21:06:51

ou pour lever une ambiguité de nom

void Foo::bar( int num )
{
this->num = num;
}

Commentaire de thiosyiasar le 14/10/2004 10:43:41

Merci pour vos commentaire
En fait j'utilise this comme en java, pour que le code soit le plus rigoureux possible.

Par contre, avez vous eu le même pb que moi lors des test avec cette classes ?

Free Heap block 1345b0 modified at 1345e4 after it was freed

Ca se produit sur le return 0; du main() si on initialise la taille initiale à 100 par exemple. à 0 ou 32 ca marche !!!

Commentaire de BruNews le 14/10/2004 11:26:57 administrateur CS

Dans le destructeur, pourquoi teste si:
if(! this->m_hHeapHandle) tenteDestruct
Ne serait pas plutot:
if(this->m_hHeapHandle) tenteDestruct ???

Desole mais pas le temps de tester tout cela.

Commentaire de thiosyiasar le 14/10/2004 11:50:44

Oooups !! en fait c'est

// Si tampon alloué
if (this->m_pszBuffer) HeapFree();

Car le buffer est initialisé à Null et le reste si aucun tampon n'a été allouée

Merci
Je corrige le source

Commentaire de DeAtHCrAsH le 14/10/2004 17:44:15

Tu utilises pas de MFC apparement alors pourquoi inclues tu l'entete précompilé stdafx.h ???
Vire ce truc c'est moche et ca fait peur.

Shell

Commentaire de thiosyiasar le 14/10/2004 18:07:52

Effectivement, un des premiers trucs que j'ai appris ici c'est de ne pas utiliser les MFC mais cette ligne est collée par VisualC et si je le vire je n'arrive plus à compiler koi ke ce soit !!!!!

unexpected end of file while looking for precompiled header directive
(pour chaque classe du projet)

T'as une idée ?

Commentaire de DeAtHCrAsH le 14/10/2004 18:11:31

Va dans les propriétés du projet et choisi "Ne pas utiliser les entetes précompilées".

Et a l'avenir si tu veux eviter ce probleme, n'utilises pas le Wizard de VC++ pour créer tes projets, mais crées un espace de travail vierge et ajoutes y au fur et a mesure tes fichiers (*.cpp, *.h, ...).

Shell

Commentaire de thiosyiasar le 14/10/2004 18:44:33

J'ai recréé un projet vide et j'ai recompilé
Ca marche
Merci pour l'info

Commentaire de Gendal67 le 15/10/2004 20:30:28

Moi ce qui m'interroge, c'est pourquoi créer ce genre de classe et se limiter alors que tu pourrais largement exploiter la surcharge operateur par exemple pour cancaténer 2 chaines, ou mettre des nombre dans des chaines....

Commentaire de thiosyiasar le 18/10/2004 10:16:50

C'est vrai... Maintenant je crois que cette classe existe déja dans la stl je crois. Son but est purement pédagogique (pour moi) et les débutant qui se mettre au c++.
Je pense effectivement qu'un truc utile et terminé serait plus intéressant. Je vais y penser

Merci

Commentaire de djl le 18/10/2004 19:21:41

oui ca existe deja, c'est le model basic_string de la stl

pas la peine de te fatiguer a reinventer la roue :)

Commentaire de morgandetoi06 le 18/10/2004 23:16:41

<headers.h>
using namespace std;

pour eviter des mettre des std:: un peu partout ;)