conversión de vacío ** a matriz 2D de int – C

2 minutos de lectura

Estoy tratando de lanzar un puntero void** a una matriz int** 2D en C

aquí está el código con el que estoy tratando de trabajar (con todos los bits extraños eliminados):

\*assume that i have a data structure called graph with some 
 *element "void** graph" in it and some element "int order" */

void initialise_graph_data(graph_t *graph)
{
    void **graph_data = NULL;
    int (*matrix)[graph->order];
    size_t size = (graph->order * graph->order) * sizeof(int);

    graph_data = safe_malloc(size); /*safe malloc works fine*/
    matrix = (int(*)[graph->order])graph_data;
    graph->graph = graph_data;
}

cuando compilo eso, funciona bien, pero me da una advertencia de que la variable ‘matriz’ está configurada pero no se usa. Realmente no quiero tener que usar la variable de matriz provisional porque se supone que la función solo inicializa la matriz, no pone nada en ella; pero si trato de convertir graph_data directamente a un int** cuando lo estoy asignando a graph->graph así:

graph->graph = (int(*)[graph->order])graph_data;

me da una asignación de advertencia de tipo de puntero incompatible.

¿Simplemente no lo estoy lanzando correctamente? ¿Alguien tiene alguna sugerencia sobre cómo puedo hacer que funcione sin la variable “matriz” provisional? o si no, ¿qué puedo hacer con esa variable para que no me dé la advertencia de que está configurada pero no utilizada?

Gracias

  • Véase también Casting desde void ** para int Cª.

    –Jonathan Leffler

    27 de agosto de 2013 a las 5:27

avatar de usuario
Un tipo programador

El compilador tiene razón, una matriz de matrices (o un puntero a una matriz) no es lo mismo que un puntero a un puntero. Solo piense en cómo se distribuirían en la memoria:

Una matriz de tamaño MxN en forma de arreglo de arreglos:

+--------------+--------------+-----+----------------+--------------+-----+------------------+
| matrix[0][0] | matrix[0][1] | ... | matrix[0][N-1] | matrix[1][0] | ... | matrix[M-1][N-1] |
+--------------+--------------+-----+----------------+--------------+-----+------------------+

A y la misma “matriz” en forma de puntero a puntero:

+-----------+-----------+-----------+-----+
| matrix[0] | matrix[1] | matrix[2] | ... |
+-----------+-----------+-----------+-----+
  |           |           |
  |           |           V
  |           |           +--------------+--------------+-----+
  |           |           | matrix[2][0] | matrix[2][1] | ... |
  |           |           +--------------+--------------+-----+
  |           |
  |           V
  |           +--------------+--------------+-----+
  |           | matrix[1][0] | matrix[1][1] | ... |
  |           +--------------+--------------+-----+
  |
  V
  +--------------+--------------+-----+
  | matrix[0][0] | matrix[0][1] | ... |
  +--------------+--------------+-----+

No importa si asigna el tamaño correcto, las dos variables simplemente son incompatibles, que es lo que le dice su compilador.

  • Excelente arte ASCII. Eso hace que tu respuesta sea elocuente (y elegante)

    – Rerito

    27 de agosto de 2013 a las 6:50

  • bueno, ¿hay alguna herramienta ascii para hacer eso?

    – artm

    4 de diciembre de 2015 a las 11:58

  • @artm No tengo idea, solo escribo estas cosas directamente en el cuadro de entrada de texto aquí en el sitio. 🙂

    – Un tipo programador

    4 de diciembre de 2015 a las 12:01

  • impresionante para un dibujo manual, se ve muy preciso (todas pointers alineado correctamente 🙂

    – artm

    4 de diciembre de 2015 a las 12:05

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad