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

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

---

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.

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

---

?

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

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 !

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?

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

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

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 ?

Citation:

---

Envoyé par millie

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

---

NON !

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.

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.

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

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 ?

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

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

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

---

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