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

Version imprimable

22/07/2006, 22h46
Pragmateek

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

Pour le passage d'un tableau multidimensionnel à une fonction faut il obligatoirement indiquer la taille de la dernière dimension?
Si oui pourquoi?

Car cela ne semble à priori pas nécessaire et de plus ce type de code:
Code:

1 2 3 void f(int t[][],unsigned taille1,unsigned taille2){ return; }
compile sans warning.

Qu'en est il exactement?

Merci.:D
22/07/2006, 22h48
millie

C'est vraiment bizarre que ça compile sans warning car il n'y a même pas int (dans unsigned taille1) !

Citation:

Envoyé par millie

C'est vraiment bizarre que ça compile sans warning car il n'y a même pas int (dans unsigned taille1) !

Peut être un coup de l'optimisation... Les paramètres sont ignorés...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> static void f(int t[][], unsigned taille1, unsigned taille2) { printf ("%d\n", t[1][2]); } int main (void) { int a[2][3]; f (a, 2, 3); return 0; }
Code:

1 2 3 4 5 6 Compiling: main.c main.c: In function `f': main.c:5: error: invalid use of array with unspecified bounds Process terminated with status 1 (0 minutes, 0 seconds) 1 errors, 0 warnings

23/07/2006, 01h20
Emmanuel Delahaye

Citation:

Envoyé par seriousme

Pour le passage d'un tableau multidimensionnel à une fonction faut il obligatoirement indiquer la taille de la dernière dimension?

La taille de toutes les dimensions (la premire peut être omise)

Citation:

Si oui pourquoi?

Si il n'y a pas les dimensions nécessaires, le compilateur ne peut pas faire les calculs de déplacement nécessaires pour atteindre l'élément.
23/07/2006, 11h16
Pragmateek
En effet en mettant du contenu dans la fonction ça ne passe plus.

Sinon écrire:

Code:

f(int t[][],...)

n'est il pas strictement équivalent à:

Code:

f(int** t,...)

?
En pratique non mais si on suit le raisonnement:
"passé en paramètre à une fonction un tableau est "transformé" en un pointeur du typpe des éléments du tableau pointant sur le premier élément du tableau";
alors int t[][]=>int* t[] qui ne passe pas plus, alors que int t[]=>int* t fonctionne.

De plus déclarer un tableau de cette manière:

Code:

int t[][3]={{1,2,3},{4,5,6},{7,8,9}};

n'est il pas équivalent à déclarer un pointeur vers une zone contenant des pointeurs qui pointent sur des zones mémoires contenant des entiers, chose qui est explicite avec les allocations dynamiques.

Et d'ailleurs pourquoi:

Code:

int t[][]={{1,2,3},{4,5,6},{7,8,9}};

ne passe pas:
Code:

1 2 3 40 elements of array `t' have incomplete type 40 array size missing in 't' 40 storage size of 't' isn't known
?
23/07/2006, 11h52
_kal_

Citation:

Envoyé par millie

C'est vraiment bizarre que ça compile sans warning car il n'y a même pas int (dans unsigned taille1) !

Par défaut, il me semble que :
unsigned int = unsigned
23/07/2006, 11h57
millie
Lors de l'appel de la fonction, seul le pointeur de pointeur va être passé en paramètre, donc a priori, il n'y a aucun moyen de connaître la taille du tableau uniquement à partir d'un pointeur.

En effet, execute ce code:
Code:

1 2 3 4 5 6 7 8 9 int t[] = {1,2,3,4,5,6}; int * u; u = &(t[0]); printf("%d %d\n", u, t); printf("%d %d\n", sizeof(u), sizeof(t));
u et t pointe sur le même endroit, mais le sizeof est différent ! En passage de paramètre, il n'y a que le pointeur, donc pas suffisament de données pour connaitre la taille !
23/07/2006, 12h12
Pragmateek

Citation:

En passage de paramètre, il n'y a que le pointeur, donc pas suffisament de données pour connaitre la taille !

Oui mais c'est au programmeur d'indiquer le taille d'une manière ou d'une autre lors du passage en paramètre:
-soit en utilisant une variable globale ou une constante avec "#define",
-soit en la passant en paramètre.

Pourquoi le compilo accepte de laisser le programmeur gérer la taille avec les tableaux unidimensionnel en transformant int t[] en int* t,
et n'accepte pas pour les tableaux multidimensionnels?
23/07/2006, 12h22
millie
En fait, un tableau à deux dimension, ce n'est pas vraiment multidimensionnelle, mais un tableau de pointeur constant !!

C'est à dire que:
Code:

1 2 3 4 5 6 7 int t[] ={1,2,3}; int r[] = {4 ,5,6}; int * y [2]; y[0] = t; y[1] = r;
Fonctionne mais:
Code:

1 2 3 4 5 6 7 8 int t[] ={1,2,3}; int r[] = {4 ,5,6}; int u[2][3]; u[0] = t;
ne fonctionne pas.

Personnellement, j'ai toujours cru que l'on ne pouvait avoir d'aucune manière que ce soit la taille d'un tableau ! Mais j'ai appris que si le tableau est déclaré avec un pointeur constant, en utilisant sizeof sans la même fonction, on peut obtenir sa taille ! (je pensais que sizeof était une commande du précompilateur qui ne fonctionnait que sur sur les types !)

Mais j'ai toujours pris l'habitude de passer les tailles en paramètres si le tableau est peu utilisé ou de faire un TAD sinon (qui a l'avantage que l'on peut tout passer en allocation dynamique rapidement si c'est bien programmé) !
23/07/2006, 12h33
Pragmateek
Oui mais en passage de paramètre pourquoi cette transformation "tableau=>pointeur" n'a pas lieu?

Pourquoi ne pas transformer:
Code:

1 2 3 {{1,2,3} {4,5,6} {7,8,9}}
en:

Code:

{p1,p2,p3}

avec:
p1=&1
p2=&4
p3=&7
puis en:
pp1 avec pp1=&p1;
puis juste manipuler la zone mémoire comme une zone allouée dynamiquement via un pointeur sur pointeur "int**"?
23/07/2006, 12h46
Emmanuel Delahaye
Citation:

Envoyé par seriousme

En effet en mettant du contenu dans la fonction ça ne passe plus.

Sinon écrire:

Code:

f(int t[][],...)

Pas du C.

Citation:

n'est il pas strictement équivalent à:

Code:

f(int** t,...)

?

Absolument pas. int ** est le type de l'adresse d'un pointeur sur int ou d'un tableau de pointeurs sur int. Rien à voir.

Citation:

En pratique non mais si on suit le raisonnement:

N'insiste pas, c'est faux. T [][] n'existe pas. C'est clair ?

Citation:

De plus déclarer un tableau de cette manière:

Code:

int t[][3]={{1,2,3},{4,5,6},{7,8,9}};

n'est il pas équivalent à déclarer un pointeur vers une zone contenant des pointeurs qui pointent sur des zones mémoires contenant des entiers, chose qui est explicite avec les allocations dynamiques.

Non. Un tableau, quelque soit ses dimensions est toujours linéraire.
Citation:
Et d'ailleurs pourquoi:

Code:

int t[][]={{1,2,3},{4,5,6},{7,8,9}};

ne passe pas:

Code:

1 2 3 40 elements of array `t' have incomplete type 40 array size missing in 't' 40 storage size of 't' isn't known

?
Puis qu'on te dit que T[][] n'existe pas. T'es bouché ou quoi ? Fait trop chaud ? T'as le cerveau qui fond ?
23/07/2006, 12h47
Emmanuel Delahaye

Citation:

Envoyé par millie

En fait, un tableau à deux dimension, ce n'est pas vraiment multidimensionnelle, mais un tableau de pointeur constant !!

NON !
23/07/2006, 12h50
Emmanuel Delahaye

Citation:

Envoyé par millie

(je pensais que sizeof était une commande du précompilateur qui ne fonctionnait que sur sur les types !)

Pas de '#'. Ce n'est donc pas une 'commande du precompilateur'. C'est un opérateur C qui fonctionne sur des expressions constantes. Celà inclue le type et les tailles explicites.
23/07/2006, 12h50
Pragmateek

Citation:

Puis qu'on te dit que T[][] n'existe pas.

En passage de paramètre OK mais à la déclaration l'interprétation:
"créer un tableau bidimensionnel dont la première zone contient 1,2,3 puis la seconde 4,5,6 et enfin la troisième 7,8,9" semble évidente.
23/07/2006, 12h55
Emmanuel Delahaye
Citation:
Envoyé par seriousme

Oui mais en passage de paramètre pourquoi cette transformation "tableau=>pointeur" n'a pas lieu?

Pourquoi ne pas transformer:

Code:

1 2 3 {{1,2,3} {4,5,6} {7,8,9}}

en:

Code:

{p1,p2,p3}

avec:
p1=&1
p2=&4
p3=&7
puis en:
pp1 avec pp1=&p1;
puis juste manipuler la zone mémoire comme une zone allouée dynamiquement via un pointeur sur pointeur "int**"?
La transformation se fait bien et c'est bien, comme toujours avec les tableaux, l'adresse du premier élément qui est transmis. Les autres indications de tailles servent à fair les cacluls d'adresse des éléments selon la formule (2 dimensons) :

p = p0 + (lin * NB_COL) + col

On voit bien qu'on a pas besoin de NB_LIN...
23/07/2006, 12h56
Emmanuel Delahaye

Citation:

Envoyé par seriousme

En passage de paramètre OK mais à la déclaration l'interprétation:
"créer un tableau bidimensionnel dont la première zone contient 1,2,3 puis la seconde 4,5,6 et enfin la troisième 7,8,9" semble évidente.

Mais c'est pas possible... CA N'EXISTE PAS. OK ?
23/07/2006, 12h59
millie

Citation:

Envoyé par Emmanuel Delahaye

NON !

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).
23/07/2006, 13h00
David.Schris

Bon...

Avant de nous fâcher un expert, certains pourraient peut-être réviser un peu et lire un cours de C et notamment les parties concernant les tableaux , les tableaux multidimensionnels et les différences entre tableaux et pointeurs ?
Dans le doute, lisez tout le cours.

Enfin...c'est juste une idée...
23/07/2006, 13h06
Pragmateek
Citation:

La transformation se fait bien

Pas vraiment car on ne se retrouve pas avec un "int**".
Pourquoi ne pas laisser au programmeur la possibilité de gérer la zone mémoire
via un "int**" au lieu de devoir faire:
Code:

1 2 3 4 int t1[]={1,2,3}; int t2[]={4,5,6}; int t3[]={7,8,9}; int* t[]={&t1[0],&t2[0],&t3[0]};
23/07/2006, 13h18
Pragmateek

Citation:

CA N'EXISTE PAS

La question n'est pas de savoir si ça existe ou pas mais de savoir le pourquoi.
Ce type de déclaration semble explicite et en Java par exemple ça passe sans problème: le compilo comprend "c'est un tableau à 2 dimension ...".

D'ailleurs comment indiquer dans les paramètres de la fonction le type "pointeur sur tableau"?
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.