Discussion :

[mecaplus]

Merci pour vos réponses, vos multiples propositions, ça montre la difficulté liée à ce type d'exercices ou simplement les différentes possibilités qu'offre ce langage.

J'avoue que je ne suis plus où mettre la tête et je pense que je dois prendre le temps qu'il faut pour relire et surtout comprendre et étudier toute cette richesse.

Merci

[pjlan]

Bonjour,

Je me permet de déterrer le topic car récemment je suis tombé sur une fonction à la fois très intéressante et surprenante (pas de moi) qui permet d'allouer un tableau à n dimension avec un seul malloc et le mieux dans tout ça ç'est que la libération se fait en un seul free (ce qui au passage économise beaucoup de temps machine, en plus du reste !)

voici la dite fonction (il faut s'accrocher quand même devant une telle puissance):
n : nombre de dimensions
tab : tableau des dimension
elemSize : taille d'un élément de base

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
 
/* pas de moi                                                                                                                                                                                  
http://clubnix.fr/node/382 */
void* array_alloc (int n, int tab[], size_t elemSize)                                                                                                                                                                     
{                                                                                                                                                                                                                   
  int i,j;                                                                                                                                                                                                          
  int pro;                                                                                                                                                                                                          
  int sum;                                                                                                                                                                                                          
  size_t dataSize;                                                                                                                                                                                                  
  size_t  blocSize = 0;                                                                                                                                                                                             
  void* ptrAlloc;                                                                                                                                                                                                   
 
  void *ptrBase, *ptrP;                                                                                                                                                                                             
 
  if (tab == NULL || n == 0 || elemSize == 0) {                                                                                                                                                                     
    return NULL;                                                                                                                                                                                                    
  }                                                                                                                                                                                                                 
  if (n == 1) {                                                                                                                                                                                                     
    return malloc (tab[0] * elemSize);                                                                                                                                                                              
  }                                                                                                                                                                                                                 
  sum = 0;                                                                                                                                                                                                          
  pro = 1;                                                                                                                                                                                                          
  for (i = 0; i < n - 1; i++){                                                                                                                                                                                      
    pro *= tab[i];                                                                                                                                                                                                  
    sum += pro;                                                                                                                                                                                                     
  }                                                                                                                                                                                                                 
 
  blocSize  = sum * PTR_SIZE + pro * elemSize * tab[i];                                                                                                                                                             
 
  if ((ptrAlloc = malloc (blocSize)) == NULL){                                                                                                                                                                      
      return NULL;                                                                                                                                                                                                  
  }                                                                                                                                                                                                                 
  ptrBase = ptrP = ptrAlloc;                                                                                                                                                                                        
  for (i = 0, pro = 1; i < n - 1; i++) {                                                                                                                                                                            
      pro *= tab[i];                                                                                                                                                                                                
      ptrBase += pro * PTR_SIZE;                                                                                                                                                                                    
      dataSize = (i == n - 2) ? elemSize : PTR_SIZE;                                                                                                                                                                
      for (j = 0; ptrP < ptrBase; ptrP += PTR_SIZE, j++) {                                                                                                                                                          
        *((void**)ptrP) = ptrBase + tab[i+1] * j * dataSize;                                                                                                                                                        
      }                                                                                                                                                                                                             
  }                                                                                                                                                                                                                 
  return ptrAlloc;                                                                                                                                                                                                  
}

[mecaplus]

Bonjour,

Merci diogene, je vais lire ton code à tête reposée et essayer de le comprendre, de le tester et je reviendrais avec des nouvelles questions s'il y a des endroits qui ne sont pas très claire pour moi.

J'avais un peu mis de côté cette allocation pour avancer sur autre chose et voici le moment de replonger dans cette épreuve.

Quant à la version postée par Pjlan, elle me paraît plus difficile à comprendre par rapport à mon niveau et par rapport à celle de diogene.


Merci à toutes et à tous pour vos contributions.