Indication de la taille de la seconde dimension d'un tableau passé en paramètre?

Version imprimable

Voir 40 message(s) de cette discussion en une page

23/07/2006, 13h32
Emmanuel Delahaye

Citation:

Envoyé par seriousme

Pas vraiment car on ne se retrouve pas avec un "int**".

Mais arrête d'inventer quand tu ne connais pas. D'où sort-tu cette anerie ? Tu as relus les cours comme il a été suggéré ? C'est pas possible d'insister comme ça...

Citation:

Pourquoi ne pas laisser au programmeur la possibilité de gérer la zone mémoire
via un "int**" au lieu de devoir faire:

Les bras m'en tombent... Un tableau est une séquence d'élements identiques, c'est pas un tableau de pointeurs. Il faut arréter la fumette, ça devient génant...

Citation:

Envoyé par seriousme

La question n'est pas de savoir si ça existe ou pas mais de savoir le pourquoi.

Interroge les créateurs du C. Moi, je me contente d'utiliser le C tel qu'il est défini, pas d'en contester tele ou tel aspects... Si le C ne te plait pas, invente ou utilise un autre langage.

Citation:

D'ailleurs comment indiquer dans les paramètres de la fonction le type "pointeur sur tableau"?

En utilisant un type 'pointeur sur tableau'.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <stdio.h> static void f (int (*pa)[3]) { size_t i; for (i = 0; i < sizeof *pa / sizeof **pa; i++) { printf ("%3d", (*pa)[i]); } printf ("\n"); } int main (void) { int a[3] = {1, 2, 3}; f (&a); return 0; }

23/07/2006, 13h54
Pragmateek

Bon donc en fait si il faut indiquer toute les dimensions sauf la première c'est parce que n'est passé en paramètre que l'adresse du premier élément qui est de type "pointeur sur tableau", aucune autre transformation n'est effectuée.

Merci à tous.
23/07/2006, 14h39
_kal_
Citation:

Envoyé par millie

Non quoi ? Tu n'es pas très explicite dans ce que tu dis ! Mais tu l'as rappelé après, c'est vrai qu'on accède de la manière suivante aux données, autant pour moi !

Sinon, oui, sizeof n'est pas une commande, je l'ai dit, mais je le pensais (on peut le constater en compilant avec -E).

Sizeof est un opérateur particulier d'après ce que j'ai compris. S'il est utilisé avec une constante en paramètre, alors le résultat est directement calculé lors de la compilation.

Par contre, si on a la déclaration d'un tableau de taille dynamique, tel que l'autorise la norme C99 :
Code:

1 2 3 int tab[v]; int x = sizeof tab; // Non remplacé à la compilation, car ne connait pas la valeur de v

Citation:
Envoyé par _kal_
Sizeof est un opérateur particulier d'après ce que j'ai compris. S'il est utilisé avec une constante en paramètre, alors le résultat est directement calculé lors de la compilation.

Par contre, si on a la déclaration d'un tableau de taille dynamique, tel que l'autorise la norme C99 :
Code:

1 2 3 int tab[v]; int x = sizeof tab; // Non remplacé à la compilation, car ne connait pas la valeur de v
Tu veux dire que le fait de mettre un "v" comme taille de tableau veut dire que c'est un tableau de taille dynamique ?
C'est un point de la norme C99 que j'ignorais...et apparemment mon compilateur l'ignore aussi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 [d_schris@fool.internal.doubleclick.net tmp]$ cat tabDyn.c #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int tab[v]; int x = sizeof tab; printf("x = %i\n",x); exit(EXIT_SUCCESS); } [d_schris@fool.internal.doubleclick.net tmp]$ gcc -std=c99 -Wall -o tabDyn tabDyn.c tabDyn.c: In function `main': tabDyn.c:5: `v' undeclared (first use in this function) tabDyn.c:5: (Each undeclared identifier is reported only once tabDyn.c:5: for each function it appears in.) tabDyn.c:5: warning: unused variable `tab' [d_schris@fool.internal.doubleclick.net tmp]$
Evidemment, tu n'as pas le droit de me répondre que "v", dans ton exemple, est une constante puisqu'il est censé s'agir d'un tableau dynamique. Tu n'as pas le droit non plus de me dire qu'il s'agit d'une variable puisque tu as forcément lu le cours de C que j'ai précédemment indiqué et qui dit :

Citation:

Envoyé par [url]http://clips.imag.fr/commun/bernard.cassagne/Introduction_ANSI_C/node32.html[/url]

Impossible donc d'écrire :

int t[n];

où n serait une variable.

Alors pourquoi il veut pas de ce "v" magique mon compilateur ? Hein ? Pourquoi ?

23/07/2006, 16h20
DaZumba
Citation:

Envoyé par David.Schris

Alors pourquoi il veut pas de ce "v" magique mon compilateur ? Hein ? Pourquoi ?

C'est une nouveauté du C99: les variable-length arrays (VLAs).
Code:

1 2 3 4 5 int function(int n) { double array[n]; }
Il sont dynamiques dans le sens que la taille n'est pas connue à la compilation. C'est ce qui rend leur implémentation compliquée, et peu de compilateurs supportent cette nouveauté. En effet, que faire si l'allocation échoue ?

Citation:
Envoyé par David.Schris
Code:

1 2 3 4 5 int main(int argc, char *argv[]) { int tab[v]; [d_schris@fool.internal.doubleclick.net tmp]$ gcc -std=c99 -Wall -o tabDyn tabDyn.c tabDyn.c: In function `main': tabDyn.c:5: `v' undeclared (first use in this function)
Faut quant même pas écrire n'importe quoi ! v n'est pas défini !

23/07/2006, 17h19
David.Schris

Citation:

Envoyé par Emmanuel Delahaye

Faut quant même pas écrire n'importe quoi ! v n'est pas défini !

Dans le code de _kal_ non plus, justement. (<-- mauvaise foi)

Oui j'ai oublié de le définir au passage, supposant que vous supposeriez que c'était une variable :lol:

Voici un exemple plus complet :

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
 
void
usage(char * s)
{
  fprintf(stderr, "Usage : %s <entier>\n", s);
  exit(EXIT_FAILURE);
}
 
int
main(int argc, char *argv[])
{
  if (argc != 2)
    usage(argv[0]);
 
  errno = 0;
  int x = strtol(argv[1], NULL, 10);
 
  if (errno == ERANGE || errno == EINVAL || x == 0)
    usage(argv[0]);
 
  int tab[x];
  printf("Taille de tab %d\n", sizeof tab); // non évalué lors de la
					    // compilation
 
  return(EXIT_SUCCESS);
}

Code:

1
2
3
4
5
 
kal@kal-laptop ~/work $ ./test 123
Taille de tab 492
kal@kal-laptop ~/work $ ./test 12
Taille de tab 48

On voit bien ici que l'opération sizeof est évalué lors de l'exécution.

Apparemment (je n'ai pas creusé) il faut quand même faire attention quand on utilise ce genre de fonctionnalité et d'autant plus quand la taille du tableau peut être contrôlée par l'utilisateur.
D'après http://gcc.gnu.org/onlinedocs/gcc-3....le-Length.html, on déduit que l'implémentation de ce type de tableaux utilise une technique similaire à l'utilisation de la fonction alloca(). Or, cette dernière alloue de l'espace sur la pile.
La taille de la pile étant généralement relativement limitée...
Exemple :

Code:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
[d_schris@fool.internal.doubleclick.net tmp]$ cat tabDyn.c 
#include <stdio.h>
#include <stdlib.h>
 
#define MULTIPLICATEUR_TAILLE 1024
 
void tabDyn(int taille) {
	int tab[taille*MULTIPLICATEUR_TAILLE];
	unsigned long i;
 
	for (i=0 ; i < (taille*MULTIPLICATEUR_TAILLE) ; i++) {
		tab[i]=taille+(int)i;
	}
}
 
int main(int argc, char *argv[]) {
 
	if (argc != 2) {
		fprintf(stderr,"utilisation: %s taille\n",argv[0]);
		exit(EXIT_FAILURE);
	}
 
	tabDyn(atoi(argv[1]));
 
	exit(EXIT_SUCCESS);
}
 
[d_schris@fool.internal.doubleclick.net tmp]$ gcc -std=c99 -O0 -g -Wall -o tabDyn tabDyn.c 
[d_schris@fool.internal.doubleclick.net tmp]$ ./tabDyn 1024
[d_schris@fool.internal.doubleclick.net tmp]$ ./tabDyn 2048
Erreur de segmentation
[d_schris@fool.internal.doubleclick.net tmp]$ gdb ./tabDyn
GNU gdb DS Linux (9.3-1)
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i686-ds-linux"...
(gdb) disas tabDyn
Dump of assembler code for function tabDyn:
0x80484f0 <tabDyn>:	push   %ebp
0x80484f1 <tabDyn+1>:	mov    %esp,%ebp
0x80484f3 <tabDyn+3>:	sub    $0x18,%esp
0x80484f6 <tabDyn+6>:	mov    %esp,0xffffffec(%ebp)
0x80484f9 <tabDyn+9>:	mov    0x8(%ebp),%eax
0x80484fc <tabDyn+12>:	mov    %eax,%eax
0x80484fe <tabDyn+14>:	shl    $0xa,%eax
0x8048501 <tabDyn+17>:	lea    0xffffffff(%eax),%ecx
0x8048504 <tabDyn+20>:	mov    %ecx,0xfffffff0(%ebp)
0x8048507 <tabDyn+23>:	movl   $0x0,0xfffffff4(%ebp)
0x804850e <tabDyn+30>:	mov    0xfffffff0(%ebp),%eax
0x8048511 <tabDyn+33>:	mov    0xfffffff4(%ebp),%edx
0x8048514 <tabDyn+36>:	shld   $0x5,%eax,%edx
0x8048518 <tabDyn+40>:	shl    $0x5,%eax
0x804851b <tabDyn+43>:	add    $0x20,%eax
0x804851e <tabDyn+46>:	adc    $0x0,%edx
0x8048521 <tabDyn+49>:	imul   $0x4,%ecx,%eax
0x8048524 <tabDyn+52>:	add    $0x4,%eax
0x8048527 <tabDyn+55>:	add    $0xf,%eax
0x804852a <tabDyn+58>:	shr    $0x4,%eax
0x804852d <tabDyn+61>:	mov    %eax,%eax
0x804852f <tabDyn+63>:	shl    $0x4,%eax
0x8048532 <tabDyn+66>:	sub    %eax,%esp
0x8048534 <tabDyn+68>:	mov    %esp,0xffffffe8(%ebp)
0x8048537 <tabDyn+71>:	movl   $0x0,0xfffffffc(%ebp)
0x804853e <tabDyn+78>:	mov    %esi,%esi
0x8048540 <tabDyn+80>:	mov    0x8(%ebp),%eax
0x8048543 <tabDyn+83>:	mov    %eax,%eax
0x8048545 <tabDyn+85>:	shl    $0xa,%eax
0x8048548 <tabDyn+88>:	cmp    %eax,0xfffffffc(%ebp)
0x804854b <tabDyn+91>:	jb     0x8048550 <tabDyn+96>
0x804854d <tabDyn+93>:	jmp    0x8048570 <tabDyn+128>
0x804854f <tabDyn+95>:	nop    
0x8048550 <tabDyn+96>:	mov    0xfffffffc(%ebp),%eax
0x8048553 <tabDyn+99>:	mov    %eax,%eax
0x8048555 <tabDyn+101>:	lea    0x0(,%eax,4),%edx
0x804855c <tabDyn+108>:	mov    0xfffffffc(%ebp),%eax
0x804855f <tabDyn+111>:	add    0x8(%ebp),%eax
0x8048562 <tabDyn+114>:	mov    0xffffffe8(%ebp),%ecx
0x8048565 <tabDyn+117>:	mov    %eax,(%edx,%ecx,1)
0x8048568 <tabDyn+120>:	lea    0xfffffffc(%ebp),%eax
0x804856b <tabDyn+123>:	incl   (%eax)
0x804856d <tabDyn+125>:	jmp    0x8048540 <tabDyn+80>
0x804856f <tabDyn+127>:	nop    
0x8048570 <tabDyn+128>:	mov    0xffffffec(%ebp),%esp
0x8048573 <tabDyn+131>:	leave  
---Type <return> to continue, or q <return> to quit---q
Quit
(gdb) quit
[d_schris@fool.internal.doubleclick.net tmp]$

Donc : prudence.

23/07/2006, 19h07
_kal_

En effet, rien de tel que malloc avec un contrôle sur la valeur retournée. :mouarf:
24/07/2006, 19h02
Pragmateek

Encore deux questions:
-est-ce que les VLA permettraient de ne pas indiquer les tailles des dimensions autre que la première?
-est-ce que le fait qu'on doit indiquer la taille des dimensions du tableau passé en paramètre implique que l'on ne peut pas faire de fonction générique de traitement des tableaux à plusieures dimensions, d'où dans ce cas l'utilité de transformer un tableau de dimension "n" en un pointeur du type:
"T**...** p" où il y a "n" "*" et où T représente le type?
24/07/2006, 19h19
Emmanuel Delahaye

Citation:

Envoyé par seriousme

-est-ce que les VLA permettraient de ne pas indiquer les tailles des dimensions autre que la première?

Evidemment que non. Tu ne va pas créer un tableau d'une taille indéterminée...

Citation:

-est-ce que le fait qu'on doit indiquer la taille des dimensions du tableau passé en paramètre implique que l'on ne peut pas faire de fonction générique de traitement des tableaux à plusieures dimensions,

Certes, ça complique un peu, mais c'est possible. Etudie qsort() et tu vas comprendre...

Si on connait la taille de l'élément, on sait tout recalculer.

Voir 40 message(s) de cette discussion en une page