recorrer a través de capas de matriz utilizando puntero a la capa de la matriz de

Question

      |--------|  
//     /|4 4 4 |  
//     |--------| 4 | 
//    /|3 3 3 | 4 | 
//    |---------|3 | | 
//   /| 2 2 2 |3 |/
//   |---------|2 |__| 
//   | 1 1 1 |2 |/
//   | 1 1 1 |__| 
//   | 1 1 1 |/
//   |_________| 
double arr[4][3][3] = {{1,1,1,1,1,1,1,1,1},{2,2,2,2,2,2,2,2,2},{3,3,3,3,3,3,3,3,3},{4,4,4,4,4,4,4,4,4}}; 

considero que esta matriz se compone de 4 capas.

Quiero crear el puntero a la capa de la matriz y recorrer las capas de esa matriz usando el puntero.

Trato:

double (*pp1)[sizeof(arr[0])/sizeof(ar[0][0][0])]; 
pp1 = arr[0]; 

y obtener el error de intelisense: valor de tipo (doble (*) (3) `t estar asignado al doble (*) (9)

Answer 1

al tratar de averiguar esta cuestión me dieron algunos resultados.

me entero de que las siguientes afirmaciones plantea ningún error de compilador

double arr[4][4][9]; 
double (*pp3)[9]; 
pp3 = arr[0]; 

Entonces, ¿es correcto deducir del código anterior que el puntero se puede asignar a la matriz solo en caso de que el número de elementos a los que apunta sea igual a la dimensión más pequeña de la matriz?

actualización: Creo que el puntero se puede crear en la capa más pequeña de la matriz solamente.

¿Alguien puede explicar esto?

Answer 2

¿Por qué no simplemente obtener la dirección del primer elemento de una capa determinada?

double *pp1 = &ar[0][0][0]; 
double *pp2 = &ar[1][0][0]; 
/* and so on */ 

Answer 3

Así que si lo hace:

int i; 
double arr[4][3][3] = {{1,1,1,1,1,1,1,1,1},{2,2,2,2,2,2,2,2,2}, 
         {3,3,3,3,3,3,3,3,3},{4,4,4,4,4,4,4,4,4}}; 

double (*pp3)[3][3];  
pp3 = arr;  
for (i = 0; i <= 3; i++)  
{ printf("pp3 + %d is %f \n", i, ***(pp3 + i)); 
} 

A continuación presentamos lo mejor comportamiento deseado. El problema con su código es que, tal como el compilador le está diciendo, está tratando de asignar un puntero a una matriz de 9 dobles (double (*pp1)[sizeof(arr[0]/sizeof(arr[0][0][0])] evalúa a double (*pp1)[9]), pero necesita un puntero a una matriz de 3 de matriz de 3 , que es lo que declaraste con double arr[4][3][3]. De mis pruebas, gcc aceptará el double (*pp1)[9] con una advertencia de compilación, que es lo que traté de obtener en mi comentario a continuación. Espero que eso aclare las cosas.

Si desea mantener este general, entonces lo que realmente quiere es double (*pp3)[sizeof(arr[0])/sizeof(arr[0][0])][sizeof(arr[0][0])/sizeof(arr[0][0][0])], que es una maldita pesadilla.

EDITAR: Olvidé una referencia ... Debería haber copiado/pegado jaja. También se agregó una explicación sobre el comportamiento del código de la pregunta. Solucionado según los comentarios.