comment accéder à la 3-d tableau à l'aide de pointeur vers un tableau

j'ai déclaré un pointeur vers un groupe de 3-d de la matrice de qui j'ai partagé ci-dessous.J'ai un problème pour accéder aux éléments de la 3-d tableau à l'aide de pointeurs vers les 3-d tableau.

#include <stdio.h>

void main()
{
   int m,row,col;
   int *ptr,*j;
   int array[2][5][2]={10,20,30,40,50,60,70,80,90,100,18,21,3,4,5,6,7,81,9,11};
   int (*p)[5][2];   // pointer to an group of 3-d array
   p=array;
   for(m=0;m<2;m++)
   {
      ptr=p+m;
      for(row=0;row<5;row++)
      {
         ptr=ptr+row;
         for(col=0;col<2;col++)
         {
            printf("\n the vale is %d",*(ptr+col));
         }
      }
   }
}

de sortie:

 the value is 10
 the value is 20
 the value is 20
 the value is 30
 the value is 40
 the value is 50
 the value is 70
 the value is 80
 the value is 18
 the value is 21
 the value is 18
 the value is 21
 the value is 21
 the value is 3
 the value is 4
 the value is 5
 the value is 7
 the value is 81
 the value is -1074542408
 the value is 134513849

ma question est de savoir comment avoir accès aux éléments de la 3-d tableau à l'aide de pointeur sur un tableau et dans mon cas, la sortie montre mon code pas accès aux éléments 90,100,9,11 et comment puis-je accéder à cette dans le code ci-dessus.Merci à l'avance.

OriginalL'auteur tamil_innov | 2013-10-12

arrays c pointers

8

Bien que l'aplatissement de tableaux et d'y accéder comme des tableaux 1d est possible, car votre question de départ était de le faire avec des pointeurs vers les dimensions intérieures, voici une réponse qui vous donne des pointeurs à tous les niveaux, à l'aide de la tableau de décomposition du comportement.
```
#include <stdio.h>
/* 1 */
#define TABLES  2
#define ROWS    5
#define COLS    2
/* 2 */
int main()
{
/* 3 */
int array[TABLES][ROWS][COLS] = {
{ {10, 20}, {30, 40}, {50, 60}, {70, 80}, {90, 100} },
{ {18, 21}, {3, 4}, {5, 6}, {7, 81}, {9, 11} }
};
/* pointer to the first "table" level - array is 3-d but decays into 2-d giving out int (*)[5][2] */
/* name your variables meaningully */
int (*table_ptr)[ROWS][COLS] = array;  /* try to club up declaration with initialization when you can */
/* 4 */
size_t i = 0, j = 0, k = 0;
for (i = 0; i < TABLES; ++i)
{
/* pointer to the second row level - *table_ptr is a 2-d array which decays into a 1-d array */
int (*row_ptr)[COLS] = *table_ptr++;
for (j = 0; j < ROWS; ++j)
{
/* pointer to the third col level - *row_ptr is a 1-d array which decays into a simple pointer */
int *col_ptr = *row_ptr++;
for (k = 0; k < COLS; ++k)
{
printf("(%lu, %lu, %lu): %u\n", (unsigned long) i, (unsigned long) j, (unsigned long) k, *col_ptr++);  /* dereference, get the value and move the pointer by one unit (int) */
}         
}
}
return 0;   /* report successful exit status to the platform */
}
```
De code en ligne des commentaires élaborés avec référence
1. C'est bien pratique d'avoir les dimensions définies généralement quelque part et l'utiliser ailleurs; changer de à un lieu les changements à tous les lieux et évite de méchants bugs
2. main retrun est de type int et annule pas
3. C'est recommandé pas pour éviter de l'intérieur des accolades
4. Utilisation size_t à la taille de types
Problèmes dans votre code

Pour la ligne ptr=p+m;, GCC jette assignment from incompatible pointer type; la raison est p est de type int (*)[5][2] c'est à dire pointeur vers un tableau (taille 5) du tableau (taille 2) d'entiers, qui est affecté à ptr qui est juste un pointeur entier. Intead si vous la changez pour int (*ptr) [5]; et puis ne ptr = *(p + m);. C'est ce que mon code (je l'ai nommé p comme table_ptr), mais seulement qu'il n'utilise pas m mais il incrémente p directement.

Après cela, au troisième niveau (le plus profond de la boucle), vous avez besoin d'un pointeur entier dire int *x (dans mon code c'est col_ptr) qui vous feriez int *x = *(ptr + m1). Bascially vous avez besoin d'avoir trois pointeurs différents, chacun pour un niveau: int (*) [5][2], int (*) [2] et int *. J'ai nommé table_ptr, row_ptr et col_ptr.

+1 pour donner le premier lien. Merci.
Vous êtes les bienvenus. Je l'ai découvert récemment, mais il semble très utile, donc je le passe autour de vous 🙂

OriginalL'auteur legends2k
2

Réécrit votre code ci-dessous et juste utilisé le pointeur p pour imprimer tout.
```
#include <stdio.h>
void main()
{
int m,row,col;
int array[2][5][2]={10,20,30,40,50,60,70,80,90,100,18,21,3,4,5,6,7,81,9,11};
int (*p)[5][2];   // pointer to an group of 3-d array
p=array;
for(m=0;m<2;m++)
{
for(row=0;row<5;row++)
{         
for(col=0;col<2;col++)
{
printf("\n the vale is %d", *((int*)(p+m) + (row*2) + col));
}         
}
}
}
```
maintenant j'ai compris, il n'existe aucune formule générale
pourrait pls point pourquoi mon code ne fonctionne pas.
Formule générale: Combien un pointeur se déplace à venir dépendra de ce type de points de. Votre code: p=p+m fonctionné correctement comme p points pour un groupe de 2-d tableau. ptr est juste int*. ptr=ptr+row ne fonctionne pas correctement. Essayez de penser à des itérations. À la ligne =0, c'points à 10. À la ligne = 1, il vient de incréments de 1 place (1 place = taille d'un int) à 20 (et Non 2 places) ... et ainsi de suite.
J'ai indiqué dans ma réponse, quel est le problème dans votre code.

OriginalL'auteur Siddhartha Ghosh
1

Vous pouvez facilement accéder à tous les éléments simplement par une boucle à travers 2*5*2 = 20 et à l'aide d'un pointeur vers le premier élément du tableau, j'.e, array[0][0][0] en supposant 3D tableau 1D array of arrays of arrays of int'.
```
#include <stdio.h>
void main()
{
int m; //row,col;
int *ptr; //,*j;
int array[2][5][2]={10,20,30,40,50,60,70,80,90,100,18,21,3,4,5,6,7,81,9,11};
//int (*p)[5][2];   // pointer to an group of 3-d array
//p=array;
ptr = &array[0][0][0];
for(m=0;m <2;m++)
{
for (m = 0; m < 20; m++)
/* ptr=ptr+m;
for(row = 0;row < 5;row ++)
{
ptr=ptr+row;
for(col=0;col<2;col++)
{
printf("\n the vale is %d",*(ptr+col));
}
}*/
printf("\n the vale is %d", *(ptr++));
}
} 
```
J'ai commenté certaines parties de votre code et l'a laissé dans le code modifié pour vous permettre d'effacer ce que j'ai fait.

merci pour le tuyau , effectivement ptr=p+m où p est un pointeur sur un 3-d de la matrice.
J'ai édité ma réponse.
Non, le p dans votre question n'est pas un pointeur vers un tableau 3D, il est le pointeur vers un tableau 2D. Quand vous avez dit p=array;, votre tableau 3D pourri pour un pointeur vers son premier élément, qui est précisément le type de p. Si vous souhaitez un pointeur vers un tableau 3D, vous pouvez le faire avec int (*p)[2][5][2]; p = &array;. Notez que l'utilisation &array est l'un de seulement deux contextes où un tableau ne se désintègrent en un pointeur sur son premier élément.

OriginalL'auteur haccks

#include<stdio.h>
int main()
{
int array[2][2][2]={1,2,3,4,5,6,7,8};
int *p;
p=&array[0][0][0];
int i=0,j,k;
/*Accessing data using pointers*/
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
for(k=0;k<2;k++)
{
printf("%d\n",*p);
p++;
}
}
}
return 0;

}

Ceci est un exemple de code où les éléments dans un 2X2X2 tableau est accessible à l'aide de pointeurs.
Espérons que cela aide !!!!

OriginalL'auteur Benny Dalby

Vous devez vous connecter pour publier un commentaire.

De code en ligne des commentaires élaborés avec référence

Problèmes dans votre code