Conversion entier - chaine ( string )

/*
converti un nombre vers son écriture en chiffre dans une base de 2 à 16
la valeur de retour est NULL en cas d'erreur ou un pointeur vers la chaîne résultat
const long x = l'entier à convertir
const unsigned short base = la base dans laquelle écrire le nombre, notez que cette fonction n'ajoute pas de préfixe de base.
char* resultat = tableau d'entier dans lequel le résultat sera écrit si cette valeur est renseignée
*/
char* convertion(const int x,const unsigned short base, char* resultat){
 
char HEX[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

/* espace de travail */
int i, j, cpt, reste; /* reste est compris entre 0 et 16*/
char chaine[34]; /*en base 2 le plus long int se représente sur 32 octets + 1  octet final + 1 octet de signe ...*/
int quotient = x;
   
     
/* vérification de la base. il faut que ça cadre avec "HEX" */
if ((base<2)||(16<base)){
        printf("base non valide \n");
        /* ici il faudrait presque mettre un exit... ce qui est un peut violent*/
        return NULL;
}
   
   
   
    /* parce qu'on ne travaille qu'avec des entiers positifs */
if (quotient<0){
        quotient = -quotient;
}
   
   
/*initialisations*/
cpt = 0;
   
   
/* calculs */
while (quotient!=0){
      reste = quotient % base ; /* sinon: reste -= (quotient*base) */
 
            /*pour passer à la ligne suivante*/
            quotient = (int) quotient/base;
        
         /*operation qui nous interesse*/          
            chaine[cpt]=HEX[reste]; 
            cpt++;
}
   
/*ajout du signe*/
if (x<0){ /* si c'est négatif*/
        chaine[cpt]='-';
        cpt++;
}
   
     
/* si l'utilisateur ne précise pas un pointeur pour stoquer la chaine alors on crée une nouvelle "chaîne" */
/* ceci est ce que j'appelle un piège à programmeur. fuite de mémoire garantie! */
if (resultat == NULL){
        resultat = malloc(cpt*sizeof(char));
       
        /*inverse le sens de chaîne en le copiant dans la chaîne de resultat*/
        if (resultat == NULL){
            /*l'idéal serai d'écrire dans le flux d'erreur */
            printf("Ne peut pas allouer de la memoire. \n");
            /* ici il faudrait presque mettre un exit... ce qui est un peut violent*/
            return NULL;   
        }
}
   
   
/*inversion du sens de lecture de la chaîne pour obtenir le résultat*/
for(i = 0, j=cpt-1 ; i< cpt ;i++, j--){
        resultat[j]=chaine[i];
}
resultat[cpt]=0; /*caractère de fin de chaîne a NE PAS oublier normalement on écrit ' 0 '  */
   
return resultat;

}

#include <stdio.h> 
#include <stdlib.h>

/*!
 * include d'une façon ou d'une autre les codes pour
 * conversion() et pour le chronométrage.
 */

const int X = 500;
const int L =100;

int main (int argc , char** argv){
  
/* des entiers arbitraires */     
    int a = -123456789;
    int b = -153347537;
    int c = -135455594;
    int d = -158532721;
    char res1[X][L+1]; /*le résultat peut être une chaîne de 16 octets*/
 
    int i,j;
    double t;
    double t1,t2,t3,t4;   
    t1 = 0.0;    t2 = 0.0;
    t3 = 0.0;    t4 = 0.0;
     
    for (j=0; j<20000; j++){
        a+=100;
        b+=100;
        c+=100;
        d+=100;
       
        chrono_start();
        for (i=0; i<X ;  i++) {
            free (convertion(d+i,10, NULL));
        }
        t = chrono_stop();
        t4+=t;
         
        /* test méthode standard non sécurisée*/
        chrono_start();
        for (i=0; i<X ;  i++) {
            sprintf(res1[i],"%d",b+i);
        }
        t = chrono_stop();
        t2+=t;
       
       
        /* test méthode perso*/
        chrono_start();
        for (i=0; i<X ;  i++) {
            convertion(a+i,10, res1[i]);
        }
        t = chrono_stop();
        t1+=t;
         
        /* test méthode standard sécurisée*/
        chrono_start();
        for (i=0; i<X ;  i++) {
            snprintf(res1[i],L,"%d",c+i);
        }
         
        t = chrono_stop();
        t3+=t;
    }       
   
    printf("test sur %d * %d = %d calculs \n", X, j, X*j);
    printf("temps perso  : %f \n",t1);
    printf("temps perso 2: %f \n",t4);
    printf("temps std    : %f \n",t2);   
    printf("temps std sec: %f \n",t3);     

    return 0;
}