Pregunta de GDB: ¿impresión bonita de una matriz 2D?

Question

Tengo una matriz de matrices 2d [10] [10] que me gustaría inspeccionar en el momento de la depuración.

entiendo que puedo hacer esto en GDB usando

p *matrix@10 

Pero da salida a esto en una línea, por lo que es difícil de leer.

¿Hay alguna manera de tener esta salida formateada de alguna manera, digamos como una matriz?

Answer 1

Una característica importante de GDB es la capacidad de ejecutar funciones en el código depurado, por lo que puede poner en práctica lo que sea la impresión que te gusta, por ejemplo:

#include <stdio.h> 

int matrix[10][10]; 

void print(int matrix[10][10]) 
{ 
    int i, j; 
    for (i = 0; i < 10; ++i) 
    { 
     for (j = 0; j < 10; ++j) 
      printf("%d ", matrix[i][j]); 
     printf("\n"); 
    } 
} 

int main() 
{ 
    int i, j; 
    for (i = 0; i < 10; ++i) 
     for (j = 0; j < 10; ++j) 
      matrix[i][j] = i*10 + j; 
    return 0; 
} 

Después de compilar el código con el parámetro -g y se ejecuta bajo GDB puede utilizar la función de impresión de la siguiente manera:

(gdb) call print(matrix) 
0 1 2 3 4 5 6 7 8 9 
10 11 12 13 14 15 16 17 18 19 
20 21 22 23 24 25 26 27 28 29 
30 31 32 33 34 35 36 37 38 39 
40 41 42 43 44 45 46 47 48 49 
50 51 52 53 54 55 56 57 58 59 
60 61 62 63 64 65 66 67 68 69 
70 71 72 73 74 75 76 77 78 79 
80 81 82 83 84 85 86 87 88 89 
90 91 92 93 94 95 96 97 98 99 

Answer 2

siempre se puede definir una función en el BGF a hacer lo mismo. Si tuviera el siguiente código C:

#include <stdio.h> 
#define ARRAY_SIZE 5 

void printArray(int array[ARRAY_SIZE][ARRAY_SIZE]) { 
    int y; 

    for (y = 0; y < ARRAY_SIZE; y++) { 
    printf("[%d,%d,%d,%d,%d]\n", 
     array[y][0], 
     array[y][1], 
     array[y][2], 
     array[y][3], 
     array[y][4]); 
    } 
} 

int main(int argc, char *argv[]) { 
    int matrix[ARRAY_SIZE][ARRAY_SIZE] = { 
    {1,2,3,4,5}, 
    {5,1,2,3,4}, 
    {4,5,1,2,3}, 
    {3,4,5,1,2}, 
    {2,3,4,5,1}, 
    }; 

    printArray(matrix); 

    return 0; 
} 

A continuación, puede definir la siguiente función de GDB (o algo similar a ella):

(gdb) define printMatrix 
Type commands for definition of "printmatrix". 
End with a line saying just "end". 
>set $arr = $arg0 
>set $y = 0 
>while $y < 5 
>printf "[%d,%d,%d,%d,%d]\n",$arr[$y][0],$arr[$y][1],$arr[$y][2],$arr[$y][3],$arr[$y][4] 
>set $y = $y + 1 
>end 
>end 

lo que resultaría en la siguiente salida:

(gdb) printMatrix matrix 
[1,2,3,4,5] 
[5,1,2,3,4] 
[4,5,1,2,3] 
[3,4,5,1,2] 
[2,3,4,5,1] 
(gdb) 

También podría utilizar tan fácilmente ciclos anidados en su función GDB. Y, como se indicó en una respuesta anterior, siempre puede llamar a la función printArray de su programa desde GDB.

Answer 3

Esta es una extensión más útil de la última publicación. También se puede usar: var impresión @ @ cols filas

define printMatrix 
set $arr = $arg0 
set $rows = $arg1 
set $cols = $arg2 
set $i = 0 
printf "\n" 
while $i < $rows 
set $j = 0 
while $j < $cols 
printf "%8.4f,",$arr[$i*$cols + $j] 
set $j = $j + 1 
end 
printf "\n" 
set $i = $i + 1 
end 

Answer 4

Se puede hacer esto ?:

p *((double (*)[3][3])pointerToMatrix3x3) 

    (double [3][3]) $6 = { 
    [0] = ([0] = 1821.8790830216928, [1] = 0, [2] = 1622.4513098457062) 
    [1] = ([0] = 0, [1] = 1172.3930433142486, [2] = 1314.4812787191868) 
    [2] = ([0] = 0, [1] = 0, [2] = 1) 

p *((double (*)[4])pointerToVector4) 

    (double [3]) $7 = ([0] = 1821.8790830216928, [1] = 0, [2] = 1622.4513098457062) 

Funciona en LLDB - no lo he probado en el BGF. Parece mucho más fácil.