Classe sstring ou la manipulation des "string" plus intuitive

Soyez le premier à donner votre avis sur cette source.

Vue 7 425 fois - Téléchargée 276 fois

Description

cette classe permet de manipuler les string de façon plus intuitive (un peu dans le style de Visual Basic couplé avec certaines possibilités du C++)
Ce n'est pas la première et sûrement pas la dernière, elle n'est pas complète non plus, mais elle reprend toutes les fonctions de base qui permettent de manipuler les chaînes de caractères plus facilement.

Si je la poste ici, c'est tout simplement parcequ'elle m'a permis de mieux comprendre le fonctionnement des chaînes de caractères en c++ ainsi que la création de son propre type de variable.

Cette source est entièrement commentée et permettra (je l'espère) aux débutants de bien comprendre le fonctionnement de ce type de classe ainsi que des diférents éléments qui peuvent la composer (variables, fonctions, opérateurs...) (bon, parfois les commentaires peuvent être assez chaud à comprendre, j'avoue avoir du mal à expliquer certains principes que je comprends intuitivement, mais dans l'ensemble, il n'y a vraiment rien de complexe)

le code de la classe sString est visible plus bas. Le zip contient un projet VC++ 6 avec quelques exemples d'utilisation de la classe.

ok, voilà pour l'explication, maintenant j'attends vos remarques... cette source m'a permis de comprendre certains méchanismes, maintenant il serait bon d'optimiser...

a+
et bon coding !;)

Source / Exemple :


/***************************************************


#include <stdio.h>
class sString
{
		
	//#####	les données "privées" (variables, fonctions...)
	private:
			
		char * buffer;				//le "buffer" qui va contenir la chaîne de caracères
		long len_tmp;				//longueur de la chaîne

	//#####	les données publiques
	public:

		sString();					//le constructeur par défaut lorsqu'il ne contient rien
		sString(const char a);		//le constructeur lorsqu'il contient une donnée de type "char"
		sString(const char * a);	//le constructeur lorsqu'il contient un pointeur vers un type de donnée "char"
		~sString();					//le destructeur

		char	operator [](int pointeur);		//opérateur d'accès

		void	operator =(const char * a);		//opérateur d'assignement d'un pointeur de type "char"
		void	operator =(const char &a);		//opérateur d'assignement d'un caractère de type "char"
		void	operator =(const sString &a);	//opérateur d'assignement d'une autre variable de type "sString"

		friend	sString	operator +(const sString a , const sString b);	//opérateur de concaténation
		void	operator +=(const sString a);							//opérateur de concaténation (ajoute une chaîne juste après celle-ci)
		
		//operator char();			//opérateur de convertion vers un type de donnée "char"
		operator char*();			//opérateur de convertion vers un pointeur de type "char"
		operator char*() const;		//opérateur de convertion vers un pointeur de type "char"

		long Len();					//retourne la longueur de la chaîne
		int to_Int();				//converti la valeur du buffer en int

};

//###########################
//#####					#####
//#####	CONSTRUCTEURS	#####
//#####					#####

//constructeur par défaut
sString::sString()
{

	//on alloue un buffer de taille 1
	buffer = new char[1];
	
	//on spécifie la taille de cette chaîne
	len_tmp = 0;

	//on insère le caractère null qui spécifie la fin de la chaîne de caractères
	buffer[0] = '\0';

}

//constructeur lorsqu'il contient une donnée de type "char"
sString::sString(const char a)
{

	//on alloue un buffer de taille 2
	buffer = new char[2];
	
	//on spécifie la taille de cette chaîne
	len_tmp = 1;

	//on place le caractère qui a été spécifié en tant que "a"
	buffer[0] = a;

	//on insère le caractère null qui spécifie la fin de la chaîne de caractères
	buffer[1] = '\0';

}

//constructeur lorsqu'il contient un pointeur vers un type de donnée "char"
sString::sString(const char * a)
{

	int i = 0;

	//taille de la chaîne de caractères donnée en argument
	len_tmp = 0;

	//on incrémente notre pointeur "a" (ainsi que "len_tmp") jusqu'à ce qu'il arrive à la fin, de ce fait "len_tmp"
	//est égale à la taille de la chaîne de caractères vers laquelle pointe notre pointeur "a"
	while(*a)
	{
		a++;
		len_tmp++;
	}
	
	//on remet notre pointeur à zéro
	a -= len_tmp;

	//la taille de notre buffer équivaut à celle de la chaîne de caractères donnée en argument (+ 1 pour le caractère null)
	buffer = new char[len_tmp + 1];

	//on copie la chaîne "a" vers le buffer
	for (i=0; i < len_tmp ; i++)
		buffer[i] = a[i];

	//on place le caractère de fin (null)
	buffer[len_tmp] = '\0';

}

//###########################
//#####					#####
//#####	DESTRUCTEUR		#####
//#####					#####

//destructeur par défaut
sString::~sString()
{
	//delete [] buffer;
}

//###########################
//#####					#####
//#####	FONCTIONS		#####
//#####					#####

//retourne la longeur de la chaîne
long sString::Len()
{

	return len_tmp;

}

//converti la valeur du buffer en int
int sString::to_Int()
{
	
	int tmp_int=0;	//la variable temporaire qui va contenir la valeur de la variable à convertir
	int i;		//variable d'incrémentation
	int i2;		//variable d'incrémentation
	int i3;		//variable d'incrémentation
	int multi_sz;	//multiplicateur

	for(i2=0 , i=len_tmp-1 ; i>=0 ; i-- , i2++)
	{
		
		//on remet à 1 notre multiplicateur
		multi_sz = 1;

		//on calcule le multiplicateur
		for(i3=0 ; i3<i2 ; i3++)
			multi_sz *= 10;
	
		//méthode plus rapide, le problème est que si les caractères ne sont pas des chiffres, il peut se produire une erreur
		if( int(buffer[i]) == 45 )
		{
			tmp_int = -tmp_int;
			return tmp_int; //on retourne la valeur directement car le signe "-" se trouve toujours à la fin
		}

		tmp_int += ( int(buffer[i]) - 48 ) * multi_sz;
		
		/* méthode moins rapide mais plus simple à comprendre et surtout évite certaines erreurs
		switch( int(buffer[i]) )
		{
			
			case 45: //signe -
				tmp_int = -tmp_int;
				return tmp_int; //on retourne la valeur directement car le signe "-" se trouve toujours à la fin

			case 49: //1
				tmp_int += 1 * multi_sz;
				break;

			case 50: //2
				tmp_int += 2 * multi_sz;
				break;

			case 51: //3
				tmp_int += 3 * multi_sz;
				break;

			case 52: //4
				tmp_int += 4 * multi_sz;
				break;

			case 53: //5
				tmp_int += 5 * multi_sz;
				break;

			case 54: //6
				tmp_int += 6 * multi_sz;
				break;

			case 55: //7
				tmp_int += 7 * multi_sz;
				break;

			case 56: //8
				tmp_int += 8 * multi_sz;
				break;

			case 57: //9
				tmp_int += 9 * multi_sz;
				break;

		}

  • /
} return tmp_int; } //########################### //##### ##### //##### OPERATEURS ##### //##### ##### //opérateur d'accès char sString::operator [](int pointeur) { //on retourne le caractère pointé par "pointeur" dans "buffer" return buffer[pointeur]; } //opérateur d'assignement d'un pointeur de type "char" (ex: sString c = "toto";) void sString::operator =(const char * a) { int i = 0; //taille de la chaîne de caractères donnée en argument len_tmp = 0; while(*a) { a++; len_tmp++; } //on remet notre pointeur à zéro a -= len_tmp; //on supprime les données contenues dans le "buffer" delete [] buffer; //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null buffer = new char[len_tmp + 1]; //on copie la chaîne "a" vers le buffer for (i=0; i < len_tmp ; i++) buffer[i] = a[i]; //on place le caractère de fin (null) buffer[len_tmp] = '\0'; } //opérateur d'assignement d'un caractère de type "char" void sString::operator =(const char &a) { //on supprime les données contenues dans le "buffer" delete [] buffer; //on alloue un buffer de taille 2 buffer = new char[2]; //on spécifie la taille de cette chaîne len_tmp = 1; //on place le caractère qui a été spécifié en tant que "a" buffer[0] = a; //on insère le caractère null qui spécifie la fin de la chaîne de caractères buffer[1] = '\0'; } //opérateur d'assignement d'une autre variable de type "sString" (ex: sString c,d; c = d;) void sString::operator =(const sString &a) { //taille de la chaîne de caractères donnée en argument len_tmp = a.len_tmp; //on supprime les données contenues dans le "buffer" delete [] buffer; //on copie les donées dans le buffer buffer = a.buffer; } //opérateur de concaténation sString operator +(const sString a , const sString b) { /* int i = 0 , i2 = 0; long len_sz = 0; //taille des deux chaînes additionnées len_sz = a.len_tmp + b.len_tmp; //on crée une nouvelle chaîne temporaire de type "sString" et de longueur len_sz + 1 (pour le caractère null) sString Resultat; if(Resultat.buffer) delete[] Resultat.buffer; Resultat.buffer = new char[len_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=0; i < a.len_tmp ; i++) Resultat.buffer[i] = a.buffer[i]; //ensuite on copie la chaîne "b" à la suite for (i2=0 ; i < len_sz ; i++ , i2++) Resultat.buffer[i] = b.buffer[i2]; //on place le caractère de fin (null) Resultat.buffer[len_sz] = '\0'; //on retourne la chaîne return Resultat;
  • /
int i = 0 , i2 = 0; long len_sz = 0; char * buffer_sz; //taille des deux chaînes additionnées len_sz = a.len_tmp + b.len_tmp; //on alloue un buffer de la taille des deux chaînes aditionnées buffer_sz = new char[len_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=0; i < a.len_tmp ; i++) buffer_sz[i] = a.buffer[i]; //ensuite on copie la chaîne "b" à la suite for (i2=0 ; i < len_sz ; i++) { buffer_sz[i] = b.buffer[i2]; i2++; } //on place le caractère de fin (null) buffer_sz[len_sz] = '\0'; //on crée une nouvelle chaîne temporaire de type "sString" sString Resultat = buffer_sz; //on libère la mémoire delete [] buffer_sz; //on retourne la chaîne return Resultat; } //opérateur de concaténation, il permet d'ajouter une chaîne directement après celle-ci void sString::operator +=(const sString a) { int i = 0 , i2 = 0; long len_sz = 0; char * buffer_sz = new char[len_tmp]; //taille des deux chaînes additionnées len_sz = len_tmp + a.len_tmp; //on copie le buffer de la variable "locale" (pas celui de "a") for (i=0; i <= len_tmp ; i++) buffer_sz[i] = buffer[i]; //on supprime les données contenues dans le "buffer" delete [] buffer; //on défini la taille du buffer buffer = new char[len_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=0; i < len_tmp ; i++) buffer[i] = buffer_sz[i]; //ensuite on copie la chaîne "b" à la suite for (i2=0 ; i < len_sz ; i++) { buffer[i] = a.buffer[i2]; i2++; } //on place le caractère de fin (null) buffer[len_sz] = '\0'; //on spécifie la taille de la nouvelle chaîne len_tmp = len_sz; } /* //opérateur de convertion vers un type de donnée "char" sString::operator char() { return buffer[0]; }
  • /
//opérateur de convertion vers un pointeur de type "char" sString::operator char*() { return buffer; } //opérateur de convertion vers un pointeur de type "char" sString::operator char*() const { return buffer; } //########################### //##### ##### //##### FONCTIONS ##### //##### INDEPENDANTES ##### //##### DE LA CLASSE ##### //##### ##### //les fonctions prennant comme arguments des variables de type "sString" ont été supprimées étant donné //que le type "sString" fait automatiquement la conversion en "*char" lorsque nécessaire //char * sLeft(sString a , int longueur_sz); //renvoie les "n" premiers caractères d'une chaîne char* sLeft(char * a , int longueur_sz); //renvoie les "n" premiers caractères d'une chaîne //char* sRight(sString a , int longueur_sz); //renvoie les "n" derniers caractères d'une chaîne (rem: voir sLeft) char* sRight(char * a , int longueur_sz); //renvoie les "n" derniers caractères d'une chaîne //char* sMid(sString a , int depart_sz , int longueur_sz); //renvoie une chaîne de longueur "longueur_sz" commençant au caractère déterminé par "depart_sz" (rem: voir sLeft) char* sMid(char * a , int depart_sz , int longueur_sz); //renvoie une chaîne de longueur "longueur_sz" commençant au caractère déterminé par "depart_sz" //bool sCompare(sString a , sString b); //compare les deux chaînes de caractères "a" et "b" et renvoie "true" si elles concordent bool sCompare(char * a , char * b); //compare les deux chaînes de caractères "a" et "b" et renvoie "true" si elles concordent //int sStrPos(sString a , sString b , int depart_sz); //renvoie la position du premier caractère de "b" trouvé dans "a" int sStrPos(char * a , char * b , int depart_sz); //renvoie la position du premier caractère de "b" trouvé dans "a" //char** sSplit(sString a , sString b , int limite_sz); //découpe la chaîne "a" en plusieurs morceaux séparés par "b", "limite_sz" est le nombre de morceaux max à retourner (-1 = max) /* //renvoie les "n" premiers caractères d'une chaîne char * sLeft(sString a , int longueur_sz) { //on vérifie si la longueur spécifiée est supérieur à zéro if( longueur_sz <= 0 ) return ""; //non, on ne retourne rien int i = 0; //on vérifie si la longueur demandée n'est pas supérieure ou égale à celle de la chaîne "a" if( longueur_sz >= a.Len() ) return a; //oui, on retourne la chaîne telle qu'elle était //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //variable qui va contenir la chaîne de caractères de "a" char * tmp_a = a; //on copie la chaîne "a" vers le buffer for (i=0; i < longueur_sz ; i++) buffer_tmp[i] = tmp_a[i]; //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; }
  • /
//renvoie les "n" premiers caractères d'une chaîne char * sLeft(char * a , int longueur_sz) { //on vérifie si la longueur spécifiée est supérieur à zéro if( longueur_sz <= 0 ) return ""; //non, on ne retourne rien int i = 0; //taille de la chaîne de caractères donnée en argument ("a") int len_tmp = 0; while(*a) { a++; len_tmp++; } //on remet notre pointeur à zéro a -= len_tmp; //on vérifie si la longueur demandée n'est pas supérieure ou égale à celle de la chaîne "a" if( longueur_sz >= len_tmp ) return a; //oui, on retourne la chaîne telle qu'elle était //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=0; i < longueur_sz ; i++) buffer_tmp[i] = a[i]; //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; } /* //renvoie les "n" derniers caractères d'une chaîne char * sRight(sString a , int longueur_sz) { //on vérifie si la longueur spécifiée est supérieur à zéro if( longueur_sz <= 0 ) return ""; //non, on ne retourne rien int i = 0 , i2 = 0; //on vérifie si la longueur demandée n'est pas supérieure ou égale à celle de la chaîne "a" if( longueur_sz >= a.Len() ) return a; //oui, on retourne la chaîne telle qu'elle était //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //variable qui va contenir la chaîne de caractères de "a" char * tmp_a = a; //on copie la chaîne "a" vers le buffer for (i=(a.Len() - longueur_sz) ; i < a.Len() ; i++) { buffer_tmp[i2] = tmp_a[i]; i2++; } //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; }
  • /
//renvoie les "n" derniers caractères d'une chaîne char * sRight(char * a , int longueur_sz) { //on vérifie si la longueur spécifiée est supérieur à zéro if( longueur_sz <= 0 ) return ""; //non, on ne retourne rien int i = 0 , i2 = 0; //taille de la chaîne de caractères donnée en argument ("a") int len_tmp = 0; while(*a) { a++; len_tmp++; } //on remet notre pointeur à zéro a -= len_tmp; //on vérifie si la longueur demandée n'est pas supérieure ou égale à celle de la chaîne "a" if( longueur_sz >= len_tmp ) return a; //oui, on retourne la chaîne telle qu'elle était //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=(len_tmp - longueur_sz) ; i < len_tmp ; i++) { buffer_tmp[i2] = a[i]; i2++; } //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; } //renvoie une chaîne de longueur "longueur_sz" commençant au caractère déterminé par "depart_sz" char * sMid(sString a , int depart_sz , int longueur_sz) { int i = 0 , i2 = 0; //on vérifie si on ne dépasse pas la taille de la chaîne if( (depart_sz + longueur_sz + 1) > a.Len() ) longueur_sz = a.Len() - depart_sz; //on respécifie la longueur de la chaîne à retourner //on vérifie si la longueur de la chaîne est supérieur à zéro if( longueur_sz < 0 ) return ""; //non, on ne retourne rien //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //variable qui va contenir la chaîne de caractères de "a" char * tmp_a = a; //on copie la chaîne "a" vers le buffer for (i=(depart_sz) ; i < (depart_sz + longueur_sz) ; i++) { buffer_tmp[i2] = tmp_a[i]; i2++; } //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; } //renvoie une chaîne de longueur "longueur_sz" commençant au caractère déterminé par "depart_sz" char * sMid(char * a , int depart_sz , int longueur_sz) { int i = 0 , i2 = 0; //taille de la chaîne de caractères donnée en argument ("a") int len_tmp = 0; while(*a) { a++; len_tmp++; } //on remet notre pointeur à zéro a -= len_tmp; //on vérifie si on ne dépasse pas la taille de la chaîne if( (depart_sz + longueur_sz + 1) > len_tmp ) longueur_sz = len_tmp - depart_sz; //on respécifie la longueur de la chaîne à retourner //on vérifie si la longueur de la chaîne est supérieur à zéro if( longueur_sz < 0 ) return ""; //non, on ne retourne rien //on alloue un buffer de la taille de la chaîne de caractères donnée en argument + 1 pour le caractère null char * buffer_tmp = new char[longueur_sz + 1]; //on copie la chaîne "a" vers le buffer for (i=(depart_sz) ; i < (depart_sz + longueur_sz) ; i++) { buffer_tmp[i2] = a[i]; i2++; } //on place le caractère de fin (null) buffer_tmp[longueur_sz] = '\0'; //et on retourne le résultat final return buffer_tmp; } /* //compare les deux chaînes de caractères "a" et "b" et renvoie "true" si elles concordent bool sCompare(sString a , sString b) { //on vérifie d'abords si la longueur des deux chaîne est la même if( a.Len() != b.Len() ) return false; //on récupère sous forme "char" "a" et "b" char * tmp_a = new char[a.Len()] = a; char * tmp_b = new char[b.Len()] = b; //on compare chaque caractère correspondant for( int i=0 ; i<=a.Len() ; i++ ) { if(tmp_a[i] != tmp_b[i]) return false; } //si on arrive jusqu'ici, c'est que les deux chaînes sont identiques return true; }
  • /
//compare les deux chaînes de caractères "a" et "b" et renvoie "true" si elles concordent bool sCompare(char * a , char * b) { //taille de la chaîne de caractères donnée en argument ("a") int len_a = 0; while(*a) { a++; len_a++; } //on remet notre pointeur à zéro a -= len_a; //taille de la chaîne de caractères donnée en argument ("b") int len_b = 0; while(*b) { b++; len_b++; } //on remet notre pointeur à zéro b -= len_b; //on vérifie d'abords si la longueur des deux chaîne est la même if( len_a != len_b ) return false; //on compare chaque caractère correspondant for( int i=0 ; i<=len_a ; i++ ) { if(a[i] != b[i]) return false; } //si on arrive jusqu'ici, c'est que les deux chaînes sont identiques return true; } /* //renvoie la position du premier caractère de la chaîne "b" trouvée dans "a" int sStrPos(sString a , sString b , int depart_sz = 0) { //on vérifie si la taille de la chaîne à chercher n'est pas plus grande que la chaîne dans laquelle il faut chercher if( (b.Len() + depart_sz) > a.Len() ) return -1; //on calcule le nombre d'itérations à effectuer int iterations_sz = a.Len() - (b.Len() + depart_sz); //on fait une boucle for(int i=depart_sz ; i <= iterations_sz ; i++ ) { //on vérifie si la chaîne de caractères (dans "b") de même taille que "a" et commençant au caractère "i" n'est pas = à "a" if( sCompare(sMid(a , i , b.Len()) , b) ) return i; } //si on arrive ici, c'est qu'on a rien trouvé return -1; }
  • /
//renvoie la position du premier caractère de la chaîne "b" trouvée dans "a" int sStrPos(char * a , char * b , int depart_sz = 0) { int i2=0; //taille de la chaîne de caractères donnée en argument ("a") int len_a = 0; while(*a) { a++; len_a++; } //on remet notre pointeur à zéro a -= len_a; //taille de la chaîne de caractères donnée en argument ("b") int len_b = 0; while(*b) { b++; len_b++; } //on remet notre pointeur à zéro b -= len_b; //on vérifie si la taille de la chaîne à chercher n'est pas plus grande que la chaîne dans laquelle il faut chercher if( (len_b + depart_sz) > len_a ) return -1; //on calcule le nombre d'itérations à effectuer int iterations_sz = len_a - (len_b + depart_sz); //on fait une boucle for(int i=depart_sz ; i2 <= iterations_sz ; i++ ) { //on vérifie si la chaîne de caractères (dans "b") de même taille que "a" et commençant au caractère "i" n'est pas = à "a" if( sCompare(sMid(a , i ,len_b) , b) ) return i; i2++; } //si on arrive ici, c'est qu'on a rien trouvé return -1; } //découpe la chaîne "a" en plusieurs morceaux séparés par "b", "limite_sz" est le nombre de morceaux max à retourner (-1 = max) sString * sSplit(char * a , char * b , int limite_sz , int &taille_finale) { int i=0 , pos=-1 , pos2=0 ; sString * tmp_res; //taille de la chaîne de caractères donnée en argument ("a") int len_a = 0; while(*a) { a++; len_a++; } //on remet notre pointeur à zéro a -= len_a; //taille de la chaîne de caractères donnée en argument ("b") int len_b = 0; while(*b) { b++; len_b++; } //on remet notre pointeur à zéro b -= len_b; //on parcourt la chaîne "a" à la recherche de "b" autant de fois que "b" s'y trouve do { pos = sStrPos(a , b , pos + 1); i++; }while(pos > 0); //si la limite est à zéro on renvoie un tableau avec une seule valeur if(limite_sz == 0) { //on quitte ici tmp_res = new sString[0]; tmp_res[0] = ""; return tmp_res; //si une limite est spécifiée, on vérifie s'il faut en tenir compte }else if(limite_sz > 0){ if(i > limite_sz) { i = limite_sz; } } //on spécifie le nombre de résultats que le tableau va contenir taille_finale = i; //on crée un tableau de type "sString" de la taille indiquée par "i" tmp_res = new sString[i]; //on décrémente i i--; //on remet la position de départ à -1 (on y ajoute 1 par la suite à chaque itérations de la boucle for) pos = -1; //pos2 commence lui à zéro et va prendre la valeur de pos avant que celui-ci ne change pos2 = 0; for(int i2=0 ; i2<i ; i2++ ) { //on récupère la position de la première occurence de la chaîne "b" dans la chaîne "a" pos = sStrPos(a , b , pos + 1); //on récupère la chaîne de caractères située entre "pos2" et "pos" et on la place dans notre tableau tmp_res[i2] = sMid(a , pos2 , pos-pos2); pos2 = pos + len_b; } //on récupère la fin de la chaîne tmp_res[i2] = sMid(a , pos2 , len_a-pos2); return tmp_res; }

Codes Sources

Ajouter un commentaire Commentaires
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
pffffffffff

fais le avec un messageBox
et bien evidemment le
sstr_test1 = "Colinnn/1/200/200/80/90/1;Duco/1/200/200/80/90/2;Ducojh/1/20/20/80/90/2";

mais sérieusement,
ta question n'a rien trop a faire ici et polue plutot cette source.

si tu en as d'autre crée un post dans le forum

Magicalement
Nono.
__________________________

PS : je te donne une version de ton code qui marche
avec les Bxxx (regarde mes publications : BFichierTxt & BString)


BString sstr_test2 ,sstr_test1=BString BFichier::getContenu(T)
//"Colinnn/1/200/200/80/90/1;Duco/1/200/200/80/90/2;Ducojh/1/20/20/80/90/2
unsigned int ii,i,taille2,taille=sstr_test1.getNbOccurence(';');
if(!i)return;
for(i=0 ; i<=taille ; i++)
{
sstr_test2 =sstr_test1.getIemeMot(i,';');
taille2=sstr_test2.getNbOccurence('/');
for(ii=0 ; ii<taille2; ii++) {
Objets[i][ii] =sstr_test1.getIemeMot(i,'/');
}

sachant que tu as la précond que Objets soit bien init



Allé
NoRabbit, dslé pour tout ceci et cette conv s'arrete ici (pour éventuellement reprendre ds un post du forum)
Kénavo - Nono.
_______________________________________________
Messages postés
126
Date d'inscription
samedi 24 avril 2004
Statut
Membre
Dernière intervention
6 janvier 2008

Oui mais je ne veut pas mettre dans une console et puis je ne vois pas ce que ca change ...
Et puis a la place du quel =?

Colin CHARGY
colin_chargy@hotmail.com
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
à la place du = que tu commente met

printf("#%s#",sstr_test1 );

et voit ce que tu obtient.
B
Messages postés
126
Date d'inscription
samedi 24 avril 2004
Statut
Membre
Dernière intervention
6 janvier 2008

Pardon,
je n'ai pas tout compris . . .
En gros, qu'est-ce qu'il faut que je fasse?

Colin CHARGY
colin_chargy@hotmail.com
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
Colin :
avec des messageBox ou des printf ou en débug
controle que ta chaine comporte exactement la mm chose....
un car entrée ou autre peut fausser ton analyse

++
Nono.
Afficher les 16 commentaires

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.