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;
}
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.