Discussion :

[denispir]

multiple déf de tableau (dans fct test)

Bonjour,

Il m'arrive souvent d'avoir à définir un tableau de multiples fois (avec une valeur "litérale"), notamment dans des fonctions de tests. Typiquement, ce tableau contient tout ou partie des données d'un cas de test qui est exécuté plusieurs fois sur des données différentes. Exemple fictif : une fonction somme et son test (ça utilise 2-3 outils externes):

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
uint somme (uint * numbers, uint count) {
   if (count == 0) {
      printf ("*** tu rigoles ? ***\n") ;
      exit (EXIT_FAILURE) ;
   }
 
   uint i = 0 ;
   uint accu = numbers[0] ;
   for (i=1 ; i<count ; i ++) {
      accu += numbers[i] ;
   }
 
   return accu ;
}
 
void test_somme () {
   puts ("=== test somme ==================================================") ;
   uint * nums ;
   uint c ;       // count
 
   nums = (uint[]){3} ; c = 1 ;
   write_numbers (nums, c) ; printf (" --> %u\n", somme (nums, c)) ;
 
   nums = (uint[]){1,3,9} ; c = 3 ;
   write_numbers (nums, c) ; printf (" --> %u\n", somme (nums, c)) ;
 
   nums = (uint[]){} ; c = 0 ;
   write_numbers (nums, c) ; printf (" --> %u\n", somme (nums, c)) ;
 
   // .............
 
   end_test () ;
}

Alors, ma question est de comment bien écrire un tel tableau variable, à la fois sa déclaration et ses multiples définitions. Une fois écartée la syntaxe "taille fixe" uint sum [n] (en déclaration ou en définition), il reste (ditto) les syntaxes tableau variable [] et pointeur *. Alors la seule combinaison qui me semble marcher est celle que j'utilise la haut:
* pointeur '*' en déclaration
* tableau variable '[]' en définition

Mais je ne comprends pas du tout la logique du truc. A chaque fois que j'en ai besoin, il me faut chercher quelle est la bonne combinaison syntaxique.

Plus généralement, je ne comprends pas quand et pourquoi il faut utiliser une syntaxe pointeur ou une syntaxe tableau. Parfois, les deux marchent, il me semble. ???

Enfin, j'utilise ici une définition de tableau variable avec un préfixe de typage (uint[]) dont il me semble que c'est un ajout de C99. Correct ? Si oui, comment fai(sai)t-on sans cela ? (Ne me dites pas que les éléments devaient être ajoutés un à un ou je deviens fou. Et de toute façon, comment prédimensionner le tableau sans le redéfinir avant de le remplir ?).

[gerald3d]

Tout dépend des caractéristiques que tu veux donner à ton tableau. Si tu ne travailles que des nombres positifs par exemple, tu pourrais utiliser un nombre négatif pour indiquer la fin du tableau.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
while (tab[i]>=0)....

Ainsi, même si la taille au départ est finie (tab[1000] par exemple), tu peux ne travailler que sur x éléments de ce tableau sans te préoccuper du nombre contenu.

Tot ce que j'écris correspond en définitive au fonctionnement des chaînes de caractères. Tu diposes d'un pointeur char* sur le premier élément du tableau mais tu ne connais pas sa taille au premier abord. La valeur '\0' dans le tableau est là pour te le dire.

[diogene]

(uint[]){3} n'est pas un tableau variable mais est un tableau non nommé d'un élément (3) [C99]

nums = (uint[]){3} ; ici ce tableau est placé à droite du signe =, donc comme pour tout tableau, ce symbole représente l'adresse du premier élément du tableau.
Cette construction est en tout point semblable à celle-ci const char * t = "123456" où "123456" est un tableau de 7 éléments.

Plus généralement, je ne comprends pas quand et pourquoi il faut utiliser une syntaxe pointeur ou une syntaxe tableau.

Une expression qui désigne un tableau représente ce tableau uniquement dans deux cas : lorsqu'elle est opérande de sizeof ou opérande de & (adresse de). Comme ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int i = sizeof (uint[]){1,3,9} ;
uint (*c)[3] =  &(uint[]){1,3,9} ;

Parfois, les deux marchent, il me semble. ???

Elles sont indifférentes dans le seul cas de la déclaration d'un pointeur comme paramètre dans la liste des paramètres d'une fonction

Si oui, comment fai(sai)t-on sans cela ? (Ne me dites pas que les éléments devaient être ajoutés un à un ou je deviens fou. Et de toute façon, comment prédimensionner le tableau sans le redéfinir avant de le remplir ?).

A la création : uint tab[] = {1,3,9};. Ne te fais pas d'illusion, en utilisant les tableaux non nommés, tu crées autant de tableaux différents.

[denispir]

A la création : uint tab[] = {1,3,9};. Ne te fais pas d'illusion, en utilisant les tableaux non nommés, tu crées autant de tableaux différents.

Merci Diogène, ça commence à être plus clair. Surtout tes distinctions sur les cas où l'on doit employer l'une ou l'autre des syntaxes.

Par rapport à la citation ci-dessus, ça veut donc dire qu'il y avait autant de variables que de cas de tests, d'accord ? Le fait qu'il plusieurs données ne me gêne, c'est justement le but. Le fait que cela emploie plusieurs zones mémoires pourrait être gênant en production, mais là il s'agit de tests, donc "on s'en f**t", non ?
Est-ce que ce que je dis là tient la route ?

Denis

[diogene]

ça veut donc dire qu'il y avait autant de variables que de cas de tests, d'accord ?

Oui

"on s'en f**t", non ?

"C'est vous qui voyez !"