2D-Array-Verwechslung (C-Programm)

Question

Ich habe ein 2D-Array, nennen wir es "A1".

A1[rows][cols]. 

später in meinem Programm erstelle ich einen anderen 2D-Array "A2" genannt,

A2[new_rows][new_cols] 

A2 ist größer als A1 ... Gibt es eine Möglichkeit für mich, A1 die gleiche Größe & Inhalte einstellen von A2?

Answer 1

Arrays sind in C statisch, daher können Sie die Größe eines Arrays nach der Definition leider nicht ändern. Sie können jedoch erreichen, was Sie sagen, wenn Sie dynamisch zugewiesene Arrays verwenden (obwohl dies nicht genau das Gleiche ist wie das Ändern der Größe eines Arrays, da Sie bei der Neuzuweisung den Verweis auf das ursprüngliche Array verlieren). Beginnen Sie mit der Erstellung von zwei dynamisch zugewiesenen Arrays A1 und A2 mit malloc. Verwenden Sie als nächstes realloc, um A1 so zuzuweisen, dass sie dieselbe Größe wie A2 haben. Kopieren Sie abschließend den Inhalt von A2 in A1. Dies wird effektiv "Größe" A1, um die gleiche Größe wie A2 mit dem gleichen Inhalt wie A2 zu sein. Hier ist ein Beispielcode (Sie verwenden können, was Bestücken Methode ist das Richtige für Sie, ich habe gerade verwendet Füllstoff):

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

int **make2DArray(int rows, int cols); 
void populate2DArray(int **array, int rows, int cols); 
void print2DArray(int **array, int rows, int cols); 

int main(int argc, char **argv) 
{ 
    int i, j; 
    int rows = 2, cols = 3; 
    int newRows = 4, newCols = 7; 

    // Create two dynamic arrays. 
    int **A1 = make2DArray(rows, cols); 
    int **A2 = make2DArray(newRows, newCols); 

    // Populate the dynamic arrays (however you like). 
    populate2DArray(A1, rows, cols); 
    populate2DArray(A2, newRows, newCols); 

    // Print original arrays. 
    printf("A1 (before):\n"); 
    print2DArray(A1, rows, cols); 
    printf("\nA2 (before):\n"); 
    print2DArray(A2, newRows, newCols); 

    // Reallocate A1 to be same size as A2. 
    int **temp = realloc(A1, sizeof(int *) * newRows); 
    if (temp) 
    { 
    A1 = temp; 
    int *tempRow; 
    for (i = 0; i < newRows; i++) 
    { 
     tempRow = realloc(A1[i], sizeof(int) * newCols); 
     if (tempRow) 
     { 
     A1[i] = tempRow; 
     } 
    } 
    } 

    // Copy contents of A2 to A1. 
    for (i = 0; i < newRows; i++) 
    { 
    for (j = 0; j < newCols; j++) 
    { 
     A1[i][j] = A2[i][j]; 
    } 
    } 

    // Print resized A1 (should be same as A2). 
    printf("\nA1 (after):\n"); 
    print2DArray(A1, newRows, newCols); 
    printf("\nA2 (after):\n"); 
    print2DArray(A2, newRows, newCols); 
} 

int **make2DArray(int rows, int cols) { 
    // Dynamically allocate a 2D array. 
    int **array = malloc(sizeof(int *) * rows); 
    if (array) 
    { 
    for (int i = 0; i < rows; i++) 
    { 
     array[i] = malloc(sizeof(int) * cols); 
    } 
    } 

    return array; 
} 

void populate2DArray(int **array, int rows, int cols) { 
    // Populate a 2D array (whatever is appropriate). 
    int i, j; 
    for (i = 0; i < rows; i++) 
    { 
    for (j = 0; j < cols; j++) 
    { 
     array[i][j] = i + j; 
    } 
    } 
} 

void print2DArray(int **array, int rows, int cols) 
{ 
    // Print a 2D array to the terminal. 
    int i, j; 
    for (i = 0; i < rows; i++) 
    { 
    for (j = 0; j < cols; j++) 
    { 
     printf("%d ", array[i][j]); 
    } 
    printf("\n"); 
    } 
} 

Die Ausgabe an den folgenden Code wird sein:

A1 (before): 
0 1 2 
1 2 3 

A2 (before): 
0 1 2 3 4 5 6 
1 2 3 4 5 6 7 
2 3 4 5 6 7 8 
3 4 5 6 7 8 9 

A1 (after): 
0 1 2 3 4 5 6 
1 2 3 4 5 6 7 
2 3 4 5 6 7 8 
3 4 5 6 7 8 9 

A2 (after): 
0 1 2 3 4 5 6 
1 2 3 4 5 6 7 
2 3 4 5 6 7 8 
3 4 5 6 7 8 9