Discussion :

[Pragmateek]

Salut!

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 :

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

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

compile sans warning.

Qu'en est il exactement?

Merci.

[millie]

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

[Emmanuel Delahaye]

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 :

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

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 :

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

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

[Emmanuel Delahaye]

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)

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.

[Pragmateek]

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

Sinon écrire:

Code :

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

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

n'est il pas strictement équivalent à:

Code :

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

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 :

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

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 :

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

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

ne passe pas:

Code :

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

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

?

[_kal_]

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

[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 :

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

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 !

[Pragmateek]

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?

[millie]

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

C'est à dire que:

Code :

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

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 :

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

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é) !

[Pragmateek]

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

Pourquoi ne pas transformer:

Code :

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

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

en:

Code :

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

{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**"?

[Emmanuel Delahaye]

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

Sinon écrire:

Code :

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

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

Pas du C.

n'est il pas strictement équivalent à:

Code :

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

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.

En pratique non mais si on suit le raisonnement:

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

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

Code :

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

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.

Et d'ailleurs pourquoi:

Code :

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

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

ne passe pas:

Code :

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

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 ?

[Emmanuel Delahaye]

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

NON !

[Emmanuel Delahaye]

(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.

[Pragmateek]

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.

[Emmanuel Delahaye]

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

Pourquoi ne pas transformer:

Code :

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

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

en:

Code :

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

{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...

[Emmanuel Delahaye]

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 ?

[millie]

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).

[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...

[Pragmateek]

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 :

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

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]};

[Pragmateek]

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"?