Bonjour,

L'objectif est réalisé en deux temps : allocation d'un tableau de pointeur vers des chaines, allocation d'un espace pour allouer un double convertit en caracteres

Allocation pointeur sur chaine de caractères :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
/**
 * @method utils_addArgToList Permet de creer un tableau de chaine de maniere dynamique,
 * par ajout sucessif d'element
 *
 * @param p_listCol un pointeur vers un tableau de pointeur de chaine de caracteres
 *
 * @param p_sizeList Pointeur sur un int qui contient la taille du tableau pour la reallocation
 *
 * @return Un pointeur vers la zone memoire de l'argument non alloué
 */
 
- (BOOL)utils_realocList:(char***)p_listCol size:(int**)p_sizeList{
 
  // Si notre tableau d'argument est vide, on l'initialise
  if (*p_sizeList == NULL){
 
    //Alocation d'un pointeur sur un int
    *p_sizeList = malloc(1*sizeof(int));
    //Test l'allocation
    if(*p_sizeList == NULL) free(*p_sizeList);
    else
      {
	//La taille du tableau est initialisé à zero
	**p_sizeList=0;
 
	//Allocation d'un tableau de pointeur sur chaine de caractères, ici de taille 1 pour commencer
	*p_listCol=malloc(1*sizeof(char*));
 
	if (*p_listCol == NULL) free (*p_listCol);
	else
	  {
	    return YES;
	  }
      }
  }else{
    // Le tableau n'est pas vide, on ajoute un argument
    **p_sizeList += 1;
 
    // Realocation du tableau de pointeur vers caractères
    *p_listCol=realloc(*p_listCol,(**p_sizeList + 1)*sizeof(char*));
 
    return YES;
  }
  return NO;
}
Allocation de la chaine que l'on va initialiser avec un double :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
- (BOOL)utils_addDoubleToList:(char***)p_listCol withArg:(double)arg size:(int**)p_sizeList{
 
  //On realloue le tableau qui augmente la taille de p_listCol de 1
  if ([self utils_realocList:p_listCol size:p_sizeList]!=NO)
    {
      //Le max de caracteres allouable pour une conversion de double
      char *maxBuffer;
      maxBuffer=calloc(30,sizeof(char));
      //La taille retourné par snprintf, indique ou non la troncature
      int i_len = 0;
 
      if ((i_len = snprintf(maxBuffer,30,"%.15f",arg))>=30){
	printf("VALEUR DOUBLE TRONQUEE %d / %.15f\n",i_len,arg);
	free(maxBuffer);
	return NO;
      }else{
 
	//On recupere la vrai taille de notre argument
	int i_sizeArg = strlen(maxBuffer);
	// On ajoute un element à p_listCol
	// http://www.postgresql.org/docs/8.1/interactive/datatype.html#DATATYPE-NUMERIC
	// La taille d'un double avec 15 decimale et un maximum de 30 chiffres 
	printf("I SIZE ARG = %d\n",i_sizeArg);
	(*p_listCol)[**p_sizeList]=calloc(i_sizeArg+1,sizeof(char));
	strcpy((*p_listCol)[**p_sizeList],maxBuffer);
	printf("ESSAI DE DOUBLE : %s\n",(*p_listCol)[**p_sizeList]);
	free(maxBuffer);
	return YES;
      }
    }
 
  return NO;
}
Mon problème se trouve dans les arrondi, qui sont mauvais ...
Ex pour une valeur de 42005100.456840117 j'obtient dans mon buffer caractères

I SIZE ARG = 24
ESSAI DE DOUBLE : 42005100.456840120255947

Soit n'importe quoi :///
Je comprend pas trop d'ou sorte les chiffres car je fait bien un memset + un calloc (ce qui est déjç redondant me semble t il ..)

Encore merci pour votre aide,
Seb