Tableaux de chaines de caractère: fonctions implode, explode et count

Commenter

Contenu du snippet

Voici quelques fonctions utiles pour la gestion des tableaux de chaines de caractères (comme les fonctions de PHP).

explode :
scinde une chaine à partir de son délimiteur et retourne 1 tableau de chaines découpées.version php

implode :
fait l'inverse d'explode et fusionne les chaines d'un tableau en une seule chaine.
=>le paramétre optionnel n permet la fusion des n 1ers elts du tableau.

count :
retourne le nombre d'élements d'un tableau de chaines.

int countfields(char delim,char token,char* src):
retour du nombre de champs avec token d'une chaine à spliter
      • AUTRE VERSION d'Explode que j'ai un peu plus optimisée:***


int fieldsExplode(char delim,char token,char * src, char** dest)
=>Fonction ajoutée : Gére les champs entourés par guillemets , quotes ou caractere au choix)

Source / Exemple : 


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

}

Conclusion :


Voilà j'ai vu plusieurs fonctions dans ce style pour le split/explode sur ce site,
celle là est un peu différente. Mais sauf erreur de ma part, je n'ai rien vu sur implode ou join.

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 (guill76)