Cómo sumergir una matriz 2D dinámica en totalview

Siguiendo esto hilo Me gustaría compartir un problema relacionado: ¿cómo bucear int ** como matriz 2D en totalview? (en el que la solución se discute aquí). En caso de que alguien enfrente el mismo problema, ¡espero que esto ayude!

Digamos que en mi código tengo una matriz 2D dinámica configurada de la siguiente manera

     int ** array2D = new int * [5];
     for (int i = 0; i < 5; i++) {
             array2D[i] = new int [5];
     }

     for (int i = 0; i < 5; i++) {
             for (int j = 0; j < 5; j++) {
                     array2D[i][j] = i + j;
             }
     }

Ahora, en TotalView, cuando se sumerge en array2D desde Stack Frame, la ventana de variables debería aparecer y mostrar algo como esto:

Expresion: array2D, Address: 0x7fffd50efbc8
Type: int **
Value: 0x02234660 -> 0x02234690 -> 0x00000000 (0)

Los siguientes pasos son similares a los que Chris Gottbrath mencionó en el hilo Lo mencioné anteriormente, pero se vuelve un poco complicado en términos de cuándo y cómo exactamente debemos lanzar el Tipo. Entonces,

Paso 1: sumérjase en el valor del puntero para eliminar la referencia del puntero, haciendo clic con el botón central del mouse o haciendo doble clic en el valor.

Hacer esto debería darte algo como esto:

Expresion: *(((int **)array2D)), Address: 0x02234660
Type: int *
Value: 0x02234690 -> 0x00000000 (0)

Paso 2: Lanza el nivel tipo uno ahora. En el canal "Tipo", cambie int * a

int *[5]

Luego presiona enter. De esta manera, el depurador sabe que array2D es el puntero que apunta a una lista de punteros con el tamaño de 5. Observe que mi matriz dinámica es un puntero que apunta a una lista de punteros. Ahora, el valor que se muestra arriba cambiaría a algo como esto:

Field                 Value
[0]                   0x02234690 -> 0x00000000 (0)
[1]                   0x022346b0 -> 0x00000001 (1)
[2]                   0x022346d0 -> 0x00000002 (2)
[3]                   0x022346f0 -> 0x00000003 (3)
[4]                   0x02234710 -> 0x00000004 (4)

Ahora vemos que array2D tiene 5 elementos, que son punteros a sublistas. Ahora, si nos sumergimos en cualquiera de estos elementos, todavía no obtendremos la lista de enteros. Para ver los números enteros, necesitamos desreferenciar una vez más, para cada inmersión en la que entramos.

Paso 3: Digamos que queremos sumergirnos en el elemento [2] para verificar los enteros desde array2D[2][0] hasta array2D[0][4]. Cuando hacemos clic con el botón central en esa línea en el panel, vemos esto:

Expresion: (((int *[5])*(((int **)array2D))))[2], Address: 0x02234670
Type: int *
Value: 0x022346d0 -> 0x00000002 (2)

Ahora estamos mirando el puntero que apunta a la sublista número 2, que supuestamente contiene un número entero.

Paso 4: Ahora, sumérgete una vez más para desreferenciar, deberíamos ver algo como esto:

Expresion: *(((int *)(((int *[5])*(((int **)array2D))))[2])), Address: 0x022346d0
Type: int
Value: 0x00000002 (2)

Paso 5: Lanza el tipo en el segundo nivel ahora. En el canal "Tipo", cambie int a

int [5]

Luego presiona enter. Y ahí vamos: vemos los elementos array2D[2][0] - array2D[2][4]

Field                 Value
[0]                   0x00000002 (2)
[1]                   0x00000003 (3)
[2]                   0x00000004 (4)
[3]                   0x00000005 (5)
[4]                   0x00000006 (6)

Aunque la matriz de inmersión 1D es simple, la inmersión de matriz 2D parece requerir un orden cuidadoso de inmersión y lanzamiento. He intentado otras formas, pero no funcionaron correctamente. Entonces, espero que esto sea útil para alguien que se encuentre con el mismo problema.

preguntado el 12 de junio de 12 a las 22:06

1 Respuestas

Han pasado cuatro años, pero me encuentro en esta situación y encontré una respuesta a esta pregunta. La mayor parte de la respuesta se encontró en esta página de la base de conocimientos.

Cómo mostrar correctamente una matriz dinámica 2D en totalview:

  1. Sumergirse en array2D. Totalview mostrará la expresión como *(array2D) y el tipo como TYPE *. En tu caso, TYPE is int.

  2. Cambie la entrada de tipo a TYPE [B]*[A], o equivalente TYPE ([A]*)[B], donde tienes una matriz de tamaño A x B. En tu caso esto sería int [5]*[5]. Para que quede claro, el rango válido de su matriz debe ser [0][0] a [A-1][B-1].

  3. Haz clic con el botón derecho y selecciona Sumérgete en todo. Esto cambiará la expresión a algo similar a (((TYPE[B]*[A])&*(array2D)))[:] y el tipo de TYPE[A][B]. La matriz completa ahora se mostrará en Totalview.

Respondido 13 Oct 16, 01:10

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.