TABLEAUX DE CHAINES DE CARACTÈRE: FONCTIONS IMPLODE, EXPLODE ET COUNT

#include <iostream>
using namespace std;

int count(char** tabsrc)
{
    int i=0;
    while (tabsrc[i]!=NULL){i++;}
    return i;
}

char** explode( const char delim, char* src)
{
    char* start = src;
    char* ptr = src;
    char** tab;
    int i = 0, pos = 0, len = 0;
    int items = 0;
    
    //items :calcul nombre d'elements du tableau (nb delimiteurs)
    while ( *src ) { if ( *src == delim ){ items++; } src++; }
    
    //si aucun déilimiteurs pas la peine de se fatiguer
    if ( !items ) return NULL;

    //nombre element= nombre de caractere delim + 1
    items++;

    //réinit du pointeur src
    src = start;

    //allocation memoire du tableau
    tab = new char* [items] ;

    //parcours de la chaine à spliter
    while ( *ptr && i < items )
    {
        if ( *src == delim || *src == 0 )
        {
            len = 0;
            ptr = start;
            while ( ptr < src ){ len++; ptr++; }
            tab[i] = new char [len+1];
            pos = 0;
            while ( start < ptr ){ tab[i][pos] = *start; start++; pos++; }
            tab[i][pos] = 0;
            start = ptr + 1;
            i++;
        }
        src++;
    }
    //fin du tableau
    tab[i]=NULL;
    return tab;
}

char * implode(const char delim, char** tabstring, int n=0)
{
    int i = 0,size = 0, max = count(tabstring);

    char * tmp,*ptr,*start;

    if (n <= 0 || n > max)
        n = max;
    
    // calcul de la taille de la chaine (size) à allouer
    while (i < n)
    {
        ptr = tabstring[i];
        while (*ptr)
        {
            ptr++;
            size++;
        }
        i++;
    }

    // Allocation de la mémoire nécessaire à la chaine à fusionner
    tmp = new char[size+1];
    start = tmp;
    i = 0;

    //fusion
    while (i < n)
    {
       ptr=tabstring[i];
        while (*ptr)
        {
            *tmp = *ptr;
            ptr++;
            tmp++;
        }
        if (i < n-1)
            *tmp = delim;
        else *tmp = 0;
        tmp++;
        i++;
    }
    //retour de la chaine fusionnée
    return start;
}

int countfields(char delim,char token,char* src)
{
    int i=0,cntL=0;
    while (*src)
    {
        if (*src==delim)
        { 
            if ( cntL%2!=1 )
            {
                i++;
            }
        }
        if (*src==token)
            cntL++;
        src++;
    }
    return i+1;
}

int maxFieldSize(char delim,char token,char* src)
{
    int i=0,a=0,max=0,cntL=0;
    while (*src)
    {
        if (*src==delim)
        { 
            if ( cntL%2!=1 )
            {
                i++;
                if (a>max)
                    max=a;
                a=0;
            }
        }
        if (*src==token)
            cntL++;
        src++;
        a++;
    }
    return max;
}

//la meilleure version d'explode

int fieldsExplode(char delim,char token,char * src, char** dest)
{
    char* ptr;
    int i=0,cntL=0;//,cntR;
    ptr=dest[0];

    while (*src)
    {
        if (*src!=delim)
        {
            if (*src==token) cntL++;
            *ptr=*src;
            ptr++; src++;
            if (!*src) *ptr=0;
        }
        else
        {
            //si impaire à gauche on continue
            if ( cntL%2==1 )
            {
                *ptr=*src;
                ptr++;
            }
            else
            {
                *ptr=0;
                i++;
                ptr=dest[i];
            }
            src++;
        }
    }
    dest[i+1]=NULL;
    return i+1;
}
// pour tester

int main ()
{
    int items=0;
    char** explodeTest=explode(';',"voici;;un;test;d;explode");

    items=count(explodeTest);
    for (int i=0;i<items;i++)
    cout<<"Item "<<i<<": "<<explodeTest[i]<<endl;

    cout <<"Count():"<<items<<endl;

    char* implodeTest=implode(';',explodeTest);
    cout<<"IMPLODE: "<<implodeTest<<endl;
    
    return 0;
}
//exemple avec le nouvel explode
int main ()
{
    char** tableau;
    char chaine[200];
    int len;
    
    strcpy(chaine,"test;'1;2;3';;explode;;'token';2;test");
    tableau=new char* [countfields(';','\'',chaine)];
    
    for(int i=0 ; i<10;i++)
    tableau[i]=new char[maxFieldSize(';','\'',chaine)+1];
    
    len=fieldsExplode(';','\'',chaine,tableau);
    
    for(int i=0 ; i<len;i++)
    cout<<tableau[i]<<endl;

}