[C] Pointeur vers tableau Multidimensionnel

Bonjour kilian,

essaie

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
 char **p_our_char;
 char our_char[10][20];
 strcpy(our_char[0],"CHAINE0");
 strcpy(our_char[1],"CHAINE1");
 p_our_char=malloc(sizeof( char *));
 *p_our_char=our_char[0];
 *(p_our_char+1)=our_char[1];

 printf("%s\n",*p_our_char);
 printf("%s\n",*(p_our_char+1));
}

char **p_our_char

  p_our_char est l'adresse du 1er élément, donc l'adresse de pointeur de caractère
 *p_our_char est le contenu du 1er élément, donc un pointeur de caractère
**p_our_char est la donnée pointée par le 1er élément, donc un caractère.

Contrairement à un tableau où les cases sont allouées statiquement à la déclaration, un pointeur de pointeur n'alloue aucun espace.
Donc toujours malloc() pour créer ce qui peut être une colonne de pointeurs.

l'access au 1er pointeur se note *p_our_char
l'access au 2ème pointeur se note *(p_our_char +1)

 **p
    |
    |
    *p  -> our_char[0][0] our_char[0][1] ----------------our_char[0][19]  
      |
      |
      |
    *p + 9 -> our_char[9][0] our_char[9][1] ----------------our_char[9][19] 

nombre_entrée * sizeof( char *)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
 int i;
 char *p_our_char;
 char our_char[2][20];

 strcpy(our_char[0],"CHAINE0");
 strcpy(our_char[1],"CHAINE1");


 for(i=0;i<2;i++)
 {
  p_our_char=our_char[i];
  printf("%s\n",p_our_char);
 }
}

salut killian, our_char n'est pas un pointeur et p_our_char est un pointeur donc l'affectation est incompatible. En fait ton p_our_char est un pointeur vers un tableau de pointeurs. Alors qe our_hcar est un tableau de tableau, ce n'est pas implémenté de la meme maniére et tu risques de ne pas avoir ce qe tu veux. En fait lorsqe tu vas faire p_our_char[i] est un pointeur alors qe our_char[i] est un ensemble contigu de valaurs. Je ne sais pas si j'ai été clair. tafiscobar "lou waye def bopame"
la nullite n'existe pas, l'ignorance oui, ah je suppose!!!

bjr. j'aimerai savoir ou trouver un cours complet sur les matrices (tableaux à +ieurs dimensions). aidez moi please, j'ai vraiment cherché mais je trouve que des trucs trés résumés.
"tek ci briik". jamais trop tard pour apprendre.

A) RAPPELS : ALLOCATION MEMOIRE

1) statique :

char[10] unechaine;
Cette variable est allouée et sera détruire à la fin de l'appel de la fonction dans laquelle tu la déclare.
Interêt : on se prend pas la tête pour allouer / vider la mémoire
Inconvénient : c'est statique donc on alloue souvent un truc disproportionné.

Rq importante : par la suite accéder à machaine[i] revient à considérer la valeur stockée i case de taille char (car ma chaine est un char[]) après l'adresse de machaine.
Rq : En particulier on a donc *machaine <=> machaine[0]


2) dynamique

char *machaine=(char *)malloc(sizeof(char)*10); //mais à la place de 10 on peut mettre n ;o)
...
//faire mumuse sur machaine
...
free(machaine);

Interêt : allocation idéale de la mémoire
Inconvénient : faut la gérér ;o)

B) ZE PROBLEM

Maintenant on peut regarder comment allouer une matrice :

int matrice[5][5]; //alloue une matrice de manière statique

//allouer une matrice 2d dynamiquement
int **matrice2d=(int**)malloc(sizeof(int*)*nb_ligne);
for(unsigned int i=0;i<nb_ligne;i++){
   matrice2d[i]=(int*)malloc(sizeof(int)*nb_colonne);
}

//allouer une matrice 23d dynamiquement
int ***matrice3d=(int***)malloc(sizeof(int**)*nb_couche);
for(unsigned int j=0;i<nb_couche;i++){
   matrice2[j]=(int**)malloc(sizeof(int*)*nb_ligne);
   for(unsigned int i=0;i<nb_ligne;i++){
       matrice2[j][i]=(int*)malloc(sizeof(int)*nb_colonne);
   }
}

//détruire une matrice 2d
for(unsigned int i=0;i<nb_ligne;i++){
   free(matrice2d[i]);
}
free(matrice2d);

//...pour la matrice 3d je te laisse deviner ;o)

//initialiser matrice3d[i][j][k]
matrice3d[i][j][k]=2;

Après à toi de définir les opérateurs que tu veux (produits, tranposéee que sais je..;))

Bonne chance

Ok merci pour l'info :-)