C 2D-Array rotierend

Question

Ich habe einen 2D-Zeiger-Setup, der ein Gitter darstellt, das Gitter besteht aus Spalten, die 1/0 oder Null-Spalten enthalten (d. H. In keiner Zelle 1 enthalten). Diese Funktion dreht das Gitter um 90 Grad im Uhrzeigersinn, und funktioniert außer ...

Ich denke, meine Malloc könnte falsch sein, wie es funktioniert, aber ich bekomme viele über Lattenzaun Fehler in dmalloc.

Ordne ich falsche Speichermengen zu?

Auch ich wollte die Werte von * width und * height tauschen, um die neue Breite und Höhe des Rasters darzustellen, aber wenn ich das versuche, segredest das Programm nur auf dem zweiten Dreh.

Answer 1

So * Breite ist die Dimension der ersten Dimension des orig, soll es so sein sollte die Größe der zweiten Dimension von newg.

Ähnlich sollte die Höhe die Größe von Newgs zuerst sein, und daher wurden die zwei Sätze von malloc Größen falsch herum umgedreht.

Ich denke, es wäre klarer, die Werte orig_max_x und orig_max_y zu nennen, dann sollte es klar sein, wenn die Funktion die Werte falsch herum verwendet.

newg = malloc (*height * sizeof(char *)); 

    // Initialise each column 
    for (x = 0; x < *height; x++) { 
     newg[x] = malloc (*width); 
     for (y = 0; y < *width; y++) 
      newg[x][y] = 0; 
    } 

Ferner sollte es keine von newg Storage-frei, wenn Sie Werte zurückgeben möchten von spin()

Edit: Ich hatte noch einige dieser lästigen * Breite und Höhe * gemischt. Es tut uns leid. Ich schlage vor, die Namen sollten sich auf die Sache beziehen, über die sie sprechen, orig_width, orig_height wäre mir geholfen, den Code zu lesen.

Dies ist wahrscheinlich, wie ich es tun würde:

#include <stdio.h> 
#include <stdlib.h> 

char** alloc_rectangle(int *width, int *height); 
void free_rectangle(char **orig, int *width); 
char** spin (char **orig, int *width, int *height); 

int main (int argc, const char * argv[]) { 
    int width = 20; 
    int height = 30; 

    char** orig = alloc_rectangle(&width, &height); 
    char** newg = spin(orig, &width, &height); 


    return 0; 
} 

char** alloc_rectangle(int *width, int *height) 
{ 
    char **newg = calloc (*width, sizeof(char *)); 

    // Initialise each column 
    for (int x = 0; x < *width; x++) { 
     newg[x] = calloc (*height, sizeof(char)); 
    } 
    return newg; 
} 

void free_rectangle(char **orig, int *width) 
{ 
    // free memory for old grid 
    for (int x = 0; x < *width; x++) { 
     if (orig[x] != NULL) { 
      free (orig[x]); 
     } 
    } 

    free (orig); 
} 

char** spin (char **orig, int *width, int *height) 
{ 
    int x; 
    int y; 

    char **newg = alloc_rectangle(height, width); 

    // Rotate 
    for (x = 0; x < *width; x++) { 
     for (y = 0; y < *height; y++) 
      if (orig[x] != NULL) 
       newg[*height - 1 - y][x] = orig[x][y]; 
    } 

    return newg; 
} 

WARNUNG Ungeprüfte Code - Spaß für alle :-)

ich es nicht glaube, ist Aufgabe des Spin kostenlos orig . Ich würde es vorziehen, einfach Platz zu machen, um das Ergebnis des Drehens zu halten. Um die Dinge besser zu machen, habe ich ein Rechteck in seine eigene Funktion gebracht. Ähnlich möchte ich immer, dass die Rechtecke einheitlich zugewiesen werden, so dass dies eine eigene Funktion wäre.

Answer 2

Sehen Sie sich noch einmal den Code an, der das Raster dreht. Ich glaube nicht, dass Sie jemals x und y Koordinaten mischen wollen, so dass ein Index wie *width - 1 - y verdächtig aussieht. Angenommen, *width = 3 und *height = 5. Dann reicht y von 0 bis 4, und Sie können mit newg[3 - 1 - 4] = newg[-2] enden.

Auch wenn Sie orig zugewiesen haben die gleiche Weise newg zugewiesen werden Sie es so befreien müssen:

for (x=0; x < *width; x++) { 
    free (orig[x]); // Free the individual columns 
} 
free (orig); // Free the array of pointers. 

Answer 3

Ich habe das gerade schnell geschrieben und es schien gut zu funktionieren mit den paar Tests, die ich darauf ausgeführt habe.

char **rotate(char **original, int *width, int *height) 
{ 
    int t_width = *height; 
    int t_height = *width; 

    char **newgrid = (char**)calloc(t_height, sizeof(char*)); 

    for(int y = 0; y < t_height; y++) 
    { 
     newgrid[y] = (char*)calloc(t_width, sizeof(char)); 
     for(int x = 0; x < t_width; x++) 
      newgrid[y][x] = original[x][y];   
    } 

    for(int y = 0; y < *height; y++) 
     free(original[y]); 
    free(original); 

    *width = t_width; 
    *height = t_height; 

    return newgrid; 
} 

Lassen Sie mich wissen, wenn es irgendwelche Probleme gibt.