Bonjour a tous, c'est mon premier post sur ce site. Je suis vraiment bloqué car je n'arrive pas a créer mon tableau de dimension 4x4x2 qui doit etre alloué dynamiquement. Je joins donc le code dans l'espoir que quelqu'un puisse voir ce qui m'a échappé  
 
 
 
char ** creation(){
     char **tab;
     tab= malloc (4*sizeof (char*));
     int i;
     for(i=0;i<4;i++){
 
            tab= malloc (4*sizeof(char));
      }
     int j;
     for(i=0;i<4;i++){
            for(j=0;j<4;j++){
                    tab[j]=malloc (2*sizeof(char));
            }
     }
     return tab;
}

Tes spécification sont trop vague.
Perso j'ai fait ça déjà.

#include <stdlib.h>
#include <stdio.h>
int main (void) {
  int Lines = 4;
  int Columns = 4;
  int Record = 2;
  int * Tab[Lines][Columns][Record];
 
 
  int L, C, R = 1;
 
  for (L = 1; L <= Lines; L++)
    {
      for (C = 1; C <= Columns; C++)
        {
          for (R = 1; R <= Record; R++)
            {
 
              Tab[L][C][R] = malloc (1 * sizeof (int));
              printf("Quel âge avez vous ?\n" );
              scanf("%d", &Tab[L][C][R]);
 
            }
        }
    }
 
  /* for (L = 1; L <= Lines; L++) */
  /*   { */
  /*     for (C = 1; C <= Columns; C++) */
  /*    { */
  /*      for (R = 1; R <= Record; R++) */
  /*        { */
 
 
  /*          printf("Line %i, Columns %i Record %i vous avez %i ans\n", L, C, R, Tab[L][C][R]); */
  /*        } */
  /*    } */
  /*   } */
  return 0;
}

 
Après si tu veux faire du dynamique c'est que tu connais pas les dimensions, ou alors, j'ai bon.

Ca compile sans warnings, ça tourne, mais c'est vraiment sans garantie, j'ai pas touché à ces trucs depuis une éternité...
 

 
Pour les constantes vaut mieux mettre des #define, c'est plus propre.

Même sans regarder les détails genre le nombre d'étoiles on voit que le code ne peut être bon:

Tu alloues de la mémoire et tu stockes un pointeur correspondant. Soit.
 
Mais alors là

tu refais la même chose 4 fois de suite en ne gardant qu'un pointeur vers la dernière adresse mémoire que malloc() retourne. Autrement dit tu alloues de la mémoire sans sauvegarder l'adresse de cette dernière, ça s'appelle un memory-leak...
 
Heu désolé par l'anneau de l'ia, mais ton code c'est un peu n'importe quoi: Tu fais un tableau de pointeurs en heu "semi-statique" (https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html) puis pour chaque pointeur tu alloues de la mémoire pour un seul int que tu utilises sans vérifier que malloc() a retourné une adresse valide... Autant faire directement

et oublier le malloc()...
D'ailleurs ton code est faux,

il faut enlever le '&' puisque Tab[][][] est déjà un pointeur vers un int.
 
(En espérant ne pas me tromper, bonne nuit...)
 
edit: Aie! J'avais même pas vu mais GCC me l'a fait remarquer: Les indices de tes tableaux!!!  

Il faut toujours compiler avec Wall

Un grand merci a toi rat de combat ! Ton code m'a beaucoup aidé et tes indications m'ont fait me rendre compte de mes erreurs.
Encore merci !

Ce truc piqué à StackOverflow est particulièrement clair sur la question:
 
 
A two-dimensional array:

is nothing more or less than an array of arrays:

There are no pointer objects here, either explicit or implicit.
Arrays are not pointers. Pointers are not arrays.
 
What often causes confusion is that an array expression is, in most contexts, implicitly converted to a pointer to its first element. (And a separate rule says that what looks like an array parameter declaration is really a pointer declaration, but that doesn't apply in this example.) An array object is an array object; declaring such an object does not create any pointer objects. Referring to an array object can create a pointer value (the address of the array's first element), but there is no pointer object stored in memory.
 
The array object foo is stored in memory as 5 contiguous elements, where each element is itself an array of 4 contiguous int elements; the whole thing is therefore stored as 20 contiguous int objects.
 
The indexing operator is defined in terms of pointer arithmetic; x[y] is equivalent to *(x + y). Typically the left operand is going to be either a pointer expression or an array expression; if it's an array expression, the array is implicitly converted to a pointer.
 
So foo[x][y] is equivalent to *(foo[x] + y), which in turn is equivalent to *(*(foo + x) + y). (Note that no casts are necessary.) Fortunately, you don't have to write it that way, and foo[x][y] is a lot easier to understand.
 
Note that you can create a data structure that can be accessed with the same foo[x][y] syntax, but where foo really is a pointer to pointer to int. (In that case, the prefix of each [] operator is already a pointer expression, and doesn't need to be converted.) But to do that, you'd have to declare foo as a pointer-to-pointer-to-int:

and then allocate and initialize all the necessary memory. This is more flexible than int foo[5][4], since you can determine the number of rows and the size (or even existence) of each row dynamically.
 
A+,

Toutafé!
 
Pour ceux qui pourraient tomber dessus sans comprendre: Il faut toujours demander au compilateur d'afficher le maximum de warnings. Pour le GCC pour cela il faut rajouter -Wall dans les paramètres.

pour Visual C aussi !