Discussion :

[nouilletonne]

Bonjour

J'aimerais connaitre à l'avance le nombre de dimension(s) d'un tableau ?
Y'a t il une fonction native en c ? ou donc faut il la fabriquer et comment car je ne vois pas du tout ?
J'ai cherché ici partout mais peut-être que je ne la vois pas ou quelle n'existe pas ! https://www.tutorialspoint.com/c_sta...rary/index.htm

J'avais bien penser à ceci pour commencer :

Code :

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

1
2
3
4
5
6
7
8
9
int y,z;
z	=	sizeof(menu)/(sizeof(int)*(sizeof(menu[0])/sizeof(int)));
y	=	(sizeof(menu[0])/sizeof(int))/2;
//valeur de ():
printf("//valeur de (z):%d\n",z);
printf("//valeur de (y):%d\n",y);
 
 
// si y ou z =0 alors y'a rien dans une des dimensions dans un tableau à 2D

mais c'est un léger pour commencer ! ça me donne la taille des tableaux mais pas le nb de dimension du tableau
Je n'ai pas la moindre idée !

[Matt_Houston]

Je n'ai pas tout saisi mais un tableau à n dimensions est une interprétation. L'adressage mémoire est toujours linéaire, unidimensionnel. L'adresse de chaque octet est un seul nombre dans l'ensemble des entiers naturels, ce n'est pas une paire ni un t-uple.

[nouilletonne]

Oui je sais qu'un tableau même à 10 dimensions utilise qu'une seule adresse mémoire

Et si en pointant sur cette adresse il y aurait peut-être un moyen de connaitre, de retrouver le nombre de dimensions ?

[ternel]

Non.
C'est impossible sans beaucoup d'aide du développeur.
les chaines de caractères y arrivent un peu en utilisant le caractère nul ('\0'), mais rien n'est prévu dans le langage uniquement.

un nom de tableau est convertible en pointeur vers son premier élément.
sizeof d'un tableau retourne la place totale qu'il occupe. A moins que ce soit un argument de fonction, car il est alors remplacé par un pointeur (à la compilation).

Mais comment peux-tu avoir besoin de connaître la dimension d'un N-tableau? A quel moment as-tu perdu cette information?

[Matt_Houston]

Oui je sais qu'un tableau même à 10 dimensions utilise qu'une seule adresse mémoire

Et si en pointant sur cette adresse il y aurait peut-être un moyen de connaitre, de retrouver le nombre de dimensions ?

Les tableaux multi-dimensionnels sont du sucre syntaxique : une illusion et rien qu'une illusion. Le compilateur génère exactement le même code pour un traitement associé à une variable déclarée int a[2*3]; ou int a[2][3]; . Une fois les calculs d'offsets réalisés, il se défausse de cette information de dimensions. Ce n'est pas la seule : la cardinalité totale de l'ensemble est également perdue (pas de bounds checking à l'exécution, sizeof x est une expression constante).

Mais comment peux-tu avoir besoin de connaître la dimension d'un N-tableau? A quel moment as-tu perdu cette information?

Je seconde cette interrogation : problème XY en vue.

[picodev]

Bonjour,

Quelques remarques :

• en C il n'y a pas de «tableaux multidimensionnels» car un type tableau n'a jamais qu'une et une seule dimension. Même une écriture comme int foo[5][10] ne déclare foo comme un tableau d'une dimension.
• ne jamais oublier qu'un tableau n'est pas un pointeur et un pointeur n'est pas un tableau
• C n'a pas d'outils d'introspections, si tu as besoin d'informations sur un type tout doit être fait à la main pour garder ces informations

Une question comme celle-ci montre un défaut de conception plus qu'un «manque» en C. Pour paraphraser Ternel, le tout n'est pas de savoir quand tu as perdu cette information mais plutôt si tu as pensé à la garder.

Edit: super grillé, mais entièrement d'accord avec mes VDD.

[sambia39]

Bonjour

Oui je sais qu'un tableau même à 10 dimensions utilise qu'une seule adresse mémoire

Et si en pointant sur cette adresse il y aurait peut-être un moyen de connaitre, de retrouver le nombre de dimensions ?

Pour connaitre le nombre d'éléments ou la taille de votre tableau vous pouvez procéder de la façon ci-dessous (a compilé & vérifié)
Attention: le code source peut contenir des erreurs

Code C :

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
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
92
93
94
95
96
97
98
99
100
101
102
103
104
 
/*
*   Constante taille tableau
*/
#define SIZEA   2
#define SIZEB   2
#define SIZEC   2
 
/*
*   LibC
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
int main( void ){
 
    /*
    *   Variable de parcourd
    */
    short i = 0;
    short j = 0;
    short k = 0;
    short l = 0;    //Variable d'incrémentations
 
    /*
    *   Diférents tableaux
    */
    short tab[10] = {0};
    short tab2[2] = {0};
    short tab3[2][2][2];
    short *ptr = NULL;
 
    /*
    *   Determination nombre élements = taille tableau
    *   (différents taille tableaux)
    */
    unsigned short size = sizeof tab / sizeof *tab;
    unsigned short size_A = sizeof tab2/ sizeof *tab2;
    unsigned short size_B = sizeof tab3/ sizeof tab3[0][0][0];
 
    /*
    *   Affichage nombre éléments
    */
    fprintf( stdout, "size tab\t = %d\n", size );
    fprintf( stdout, "size tab2\t = %d\n", size_A );
    fprintf( stdout, "size tab3\t = %d\n", size_B );
 
    /*
    *   Initialisation Tableau
    */
    for( i = 0; i< SIZEA; i++ ){
        for( j = 0; j < SIZEB; j++ ){
            for( k = 0; k < SIZEC; k++ )
                tab3[i][j][k] = l++;
        }
    }
 
    /*
    *   Affichage & comptage élements
    */
    fprintf( stdout, "Tab3\t\t = ");
    for( i = 0; i< SIZEA; i++ ){
        for( j = 0; j < SIZEB; j++ ){
            for( k = 0; k < SIZEC; k++ )
                fprintf( stdout, "%d\t", tab3[i][j][k]);
        }
    }
    fprintf( stdout, "\n");
 
    /*
    *   Allocation mémoire ptr
    */
    errno = 0;
    if( NULL == (ptr = malloc( size_B * sizeof(short) ) ) ){
        fprintf( stderr, "(%d)\t:%s\n\t:%s\n", errno,
            "Erreur allocation mémoire", strerror(errno) );
        return (EXIT_FAILURE);
    }
 
    /*
    *   initialisation
    */
    memset( ptr, 0, size_B );
    for( i = 0; i < size_B; i++ )
        *(ptr+i) = i;
 
    /*
    *   Affichage élements ptr
    */
    fprintf(stdout, "Ptr\t\t = " );
    for( i = 0; i < size_B; i++ )
        fprintf( stdout, "%d\t", *(ptr+i) );
    fprintf( stdout, "\n" );
 
    /*
    *   Free mémoire ptr
    */
    free( ptr );
    ptr = NULL;
    return (EXIT_SUCCESS);
}

à bientôt

[Sve@r]

J'ai cherché ici partout mais peut-être que je ne la vois pas ou quelle n'existe pas !

Bonjour

Comme disaient les shadocks, s'il n'y a pas de solution c'est qu'il n'y a pas de problème.

Mais bon, ici précisément la plaisanterie rejoint la réalité car (et je vais redire ce que tous t'ont déjà dit), si l'outil n'existe pas c'est qu'il n'a pas de raison d'être. Et s'il n'a pas de raison d'être, c'est déjà parce qu'effectivement un tableau même à x dimensions n'est en final qu'une longue suite d'octets (donc toujours en une dimension au niveau mémoire) mais surtout parce que tu n'as aucune raison de ne pas connaitre les dimensions des tableaux que tu crées.

Et si d'aventure le tableau t'est fourni par une librairie qui n'est pas à toi (je dis ça mais j'ai pas d'exemple en tête de librairie fournissant des tableaux xD et ça m'étonnerait même que ça existe...) ben tu auras fatalement quelque part une doc ou au pire un ".h" te donnant les dimensions en questions...
Et en fait, à bien y réfléchir, si je devais écrire un outil fournissant un tableau xD à un client, alors j'encapsulerais ce tableau dans une structure contenant donc le tableau lui-même plus des infos diverses sur le tableau dont, entre autre, ses dimensions. Donc bref a aucun moment tu n'es sensé ignorer les dimensions des tableaux que tu manipules...

[nouilletonne]

Je comprend toutes vos réponses. Et je suis entièrement d'accord qu'en C connaitre les dimensions d'un tableau perso et déclaré c'est normal.

Mais si j'ai ouvert ce sujet c'était parceque j'ai une fonction qui affiche les valeurs de tableau.
Donc j'ai autant de fonctions que de tableau selon leur nbre de dimensions.

Je me suis dis y'aurait il moyen pour que dans une seule de mes fonctions d'affichage je puisse connaitre le nbre de dimensions.
Plutôt que de passer un paramètre le nbre de dimensions et je fais des boucles sur chaque sous-tableau de mon tableau à x dimensions.
(mais ce n'est pas le but puisque pour l'affichage je veux utiliser une seule fonction et que cette fonction ne "doit" pas connaitre le nbre dimensions).
Je dois calculer donc l'ensemble des dimensions à l'intérieur de la fonction d'affichage.

J'avoue je ne suis pas revenu sur mon code depuis.

Mais si on considère qu'en utilisant sizeof je peux obtenir le nombre de blocs mémoire que va utiliser le tableau en entier.

Dans une première boucle, je peut peut-être compter le nbre de dimensions par :

• Soit je met dans chaque sous-tableau du tableau un bloc avec une valeur "témoin"/"drapeaux".
• Soit par l'intermédiaire de pointeur avec ou/et sizeof ou/et malloc, j'ai pensé qu'on pourrait assigner, ou/et connaitre les valeurs des blocs mémoires du tableau en entier et tester les tailles des sous-tableaux etc...
  Et quand les blocs saute d'un sous-tableau à un autre du tableau et compter le nb de dimensions.

Mais pour l'instant c'est juste une idée vu que je ne me suis pas replongé dans le code lui même !
C'est peut-être faire compliqué par rapport à un bloc avec des valeurs "témoins"/"drapeau" (première solution).

Qu'en pensez vous ?

[foetus]

une valeur "témoin"/"drapeaux".

Juste pour la terminologie valeur sentinelle (<- lien wiki)

[Sve@r]

• Soit je met dans chaque sous-tableau du tableau un bloc avec une valeur "témoin"/"drapeaux".
• Soit par l'intermédiaire de pointeur avec ou/et sizeof ou/et malloc, j'ai pensé qu'on pourrait assigner, ou/et connaitre les valeurs des blocs mémoires du tableau en entier et tester les tailles des sous-tableaux etc...
  Et quand les blocs saute d'un sous-tableau à un autre du tableau et compter le nb de dimensions.

Mais pour l'instant c'est juste une idée vu que je ne me suis pas replongé dans le code lui même !
C'est peut-être faire compliqué par rapport à un bloc avec des valeurs "témoins"/"drapeau" (première solution).

Qu'en pensez vous ?

Question faisabilité c'est tout à fait possible (enfin la première solution parce que le malloc lui ne sert pas à ça).
Effectivement avec un témoin pour chaque dimension (témoin différent par dimension) tu peux "détecter" quand tu termines une dimension.

Mais c'est quand-même bien se compliquer la vie tout ça parce qu'on a arbitrairement décidé qu'on ne "devait" pas passer soi-même les dimensions à la fonction.

Moi je n'ai pas ce blocage donc si je devais écrire cette fonction, je me dirais tout simplement que pour un tableau [2][3] je lui passerais fct(tab, 2, 3, 0) et pour un tableau [2][3][4] je lui passerais fct(tab, 2, 3, 4, 0). Avec les va_args c'est assez simple de traiter ce type d'argument...

[nouilletonne]

je ne comprend pas ton 0 ?

ce n"est pas plutot par exemple :

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
 
 
void fct(type tmptab, int, ...);
 
//n dimensions 
void fct(tmptab,int n,...){
 
//verif type
va_list tmptab;
int i;
 
va_start(tmptab, n)
for(i = 0; i < n; i++) 
   {
      print(va_arg(tmptab, int));
   }
va_end(tmptab);
}
 
int main()
{
tab[3][2]={{1,2,3},{4,5}};
fct(tab,2,3,2);
   return 0;
}

[Sve@r]

je ne comprend pas ton 0 ?

ce n"est pas plutot par exemple :

Code :

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

1
2
3
 
 
void fct(type tmptab, int, ...);

Toi qui semblait avoir un blocage métapsychique avec des paramètres que tu voulais éviter tu n'hésites maintenant plus à en mettre même là où on peut s'en passer.
Le "0" me sert justement de sentinelle/témoin pour savoir où m'arrêter. Tu aurais pu le déduire tout seul...

[nouilletonne]

Oui un tableau ou un sous-tableau de dimension 0 ça donne pas grand chose... à part être aussi NULL que moi
Mais désolé j'ai dormi 1h30 cette nuit (mais rien à voir avec une fête avec des bulles dans la tête !)

Je marque résolu car une fois dans le code je crois que j'ai assez d'informations

Merci à tous !

[Matt_Houston]

Je n'ai toujours pas saisi la finalité de la chose. picodev avait souligné un point important il y a déjà quelques temps :

Une question comme celle-ci montre un défaut de conception plus qu'un «manque» en C. Pour paraphraser Ternel, le tout n'est pas de savoir quand tu as perdu cette information mais plutôt si tu as pensé à la garder.

[nouilletonne]

Pour terminer
J'avais bien pris note de sa remarque.
Certes c'est surement un manque de connaissance en C.

Mais je n'avais pas effectivement dit pourquoi je voulais faire cela à l'époque :
Comme j'avais autant de fonctions d'affichage pour les tableaux que j'avais de dimensions de tableau, j'ai voulu faire qu'une seule fonction d'affichage pour tout type de tableau quelque soit leurs nombres dimensions.

C'est tout. Et je ne savais pas comment là j'ai une solution après effectivement y'avait peut-être mieux à faire en terme de conception grace à de meilleur connaissance en C. Mais je ne vois toujours pas ? Dans le cas de mauvaise conception !?

[ternel]

En ce cas, si tu avais effectivement des tableaux (et pas des multi-pointeurs), tu peux profiter de la linéarisation.
En gros, une fonction à laquelle tu passes l'adresse du tout premier élément, et un tableau de dimension, et la taille Nde ce tableau-là.
La fonction sait afficher le cas N = 1, et dans les autres casboucle pour récursivement afficher les sous-tableaux de taille N-1

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
int tab[4][5][6] = {...};
size_t tab_sizes[3] = {4,5,6};
print_multitable_int(&tab[0][0][0], tab_sizes, 3);
 
void print_multitable_int(int* base, size_t* sizes, size_t dimensions) {
  switch (dimensions) {
    case 0:
      printf("%d\n", *base);
      return;
    case 1:
      for (int i = 0; i t<sizes[0]; ++i) {
        printf("%d ", base[i]);
      }
      printf("\n");
      return;
    default:{
      size_t shift_size = 1;
      for (int i = 0; i t<dimensions; ++i) shift_size *= sizes[i];
 
      for (int i = 0; i t<sizes[0]; ++i) {
        print_multitable_int(base+i*shift_size, sizes+1, dimensions-1);
      }
    }
  }
}

Il y a certainement moyen de faire mieux, les décalages sont probablement faux, mais l'idée générale est là.

Cela dit, si tu connais une méthode d'affichage claire pour un multi-tableau int[8][8][8], je suis curieuse. ca fait quand même 64 carrés de 8 éléments chacuns.

Je peux raffiner un peu, si tu nous montres tes fonctions d'affichage.

[nouilletonne]

dés que je replonge dans le code
mais sans avoir trop ton premier
si tu as int[9][9][9]
que pour [9]==null tu le compares
et sur une première boucle tu cptes le nb de dimension
grosso modo pour pas me compliquer la vie je vais faire une fonction
fct(tab,sizeof(tab),....)
et dans la fonction fct
le tab il va donner par ex 12345678null123145678null12345678null.... etc
à ce moment t'as le nb de dimensions et tu reboucles
en fait null équivaut à '\0' pour un tableau de char

[Sve@r]

grosso modo pour pas me compliquer la vie je vais faire une fonction fct(tab,sizeof(tab),....)

Fais très attention à ce que tu donnes à manger à sizeof car cela peut être trompeur...
Exemple

Code c :

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

1
2
char tab[]="Hello World";
char *pt=tab;

Dans cet exemple, sizeof(tab) donnera 12 (11 caractères visibles plus le '\0') alors que sizeof(pt) donnera 4 (la taille d'une adresse)

en fait null équivaut à '\0' pour un tableau de char

Oui, c'est le principe de la sentinelle: une valeur arbitrairement choisie (et ne devant pas faire partie de l'ensemble des valeurs possibles du tableau) permettant d'indiquer un élément particulier dans le tableau. Ce principe s'étend aussi aux fichiers textes (ex. le CSV)...