C Language
Übergeben Sie 2D-Arrays an Funktionen
Suche…
Übergeben Sie ein 2D-Array an eine Funktion
Die Übergabe eines 2D-Arrays an eine Funktion erscheint einfach und naheliegend und wir schreiben gerne:
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int **, int, int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int n = ROWS;
int m = COLS;
fun1(array_2D, n, m);
return EXIT_SUCCESS;
}
void fun1(int **a, int n, int m)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Aber der Compiler, hier GCC in Version 4.9.4, schätzt es nicht.
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c11 passarr.c -o passarr
passarr.c: In function ‘main’:
passarr.c:16:8: warning: passing argument 1 of ‘fun1’ from incompatible pointer type
fun1(array_2D, n, m);
^
passarr.c:8:6: note: expected ‘int **’ but argument is of type ‘int (*)[2]’
void fun1(int **, int, int);
Dafür gibt es zwei Gründe: Das Hauptproblem besteht darin, dass Arrays keine Zeiger sind und der zweite Nachteil ist der sogenannte Zeigerzerfall . Durch die Übergabe eines Arrays an eine Funktion wird das Array in einen Zeiger auf das erste Element des Arrays zerlegt - im Falle eines 2d-Arrays zerfällt es in einen Zeiger auf die erste Zeile, da in C-Arrays die Zeilen zuerst sortiert werden.
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int (*)[COLS], int, int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int n = ROWS;
int m = COLS;
fun1(array_2D, n, m);
return EXIT_SUCCESS;
}
void fun1(int (*a)[COLS], int n, int m)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Es ist notwendig, die Anzahl der Zeilen zu übergeben, sie können nicht berechnet werden.
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int (*)[COLS], int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int rows = ROWS;
/* works here because array_2d is still in scope and still an array */
printf("MAIN: %zu\n",sizeof(array_2D)/sizeof(array_2D[0]));
fun1(array_2D, rows);
return EXIT_SUCCESS;
}
void fun1(int (*a)[COLS], int rows)
{
int i, j;
int n, m;
n = rows;
/* Works, because that information is passed (as "COLS").
It is also redundant because that value is known at compile time (in "COLS"). */
m = (int) (sizeof(a[0])/sizeof(a[0][0]));
/* Does not work here because the "decay" in "pointer decay" is meant
literally--information is lost. */
printf("FUN1: %zu\n",sizeof(a)/sizeof(a[0]));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Die Anzahl der Spalten ist vordefiniert und somit zur Kompilierzeit festgelegt. Der Vorgänger des aktuellen C-Standards (dh ISO / IEC 9899: 1999, derzeit ISO / IEC 9899: 2011) implementierte VLAs (TODO: link it) und Obwohl der aktuelle Standard dies optional macht, unterstützen ihn fast alle modernen C-Compiler (TODO: Prüfen Sie, ob MS Visual Studio es jetzt unterstützt).
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int (*)[], int rows, int cols);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = (i + 1) * (j + 1);
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(array_2D, rows, cols);
exit(EXIT_SUCCESS);
}
void fun1(int (*a)[], int rows, int cols)
{
int i, j;
int n, m;
n = rows;
/* Does not work anymore, no sizes are specified anymore
m = (int) (sizeof(a[0])/sizeof(a[0][0])); */
m = cols;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Das funktioniert nicht, der Compiler beschwert sich:
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c99 passarr.c -o passarr
passarr.c: In function ‘fun1’:
passarr.c:168:7: error: invalid use of array with unspecified bounds
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
Etwas klarer wird es, wenn wir beim Aufruf der Funktion absichtlich einen Fehler machen, indem wir die Deklaration in void fun1(int **a, int rows, int cols) . Dies hat zur Folge, dass sich der Compiler auf eine andere, aber ebenso nebulöse Weise beschwert
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c99 passarr.c -o passarr
passarr.c: In function ‘main’:
passarr.c:208:8: warning: passing argument 1 of ‘fun1’ from incompatible pointer type
fun1(array_2D, rows, cols);
^
passarr.c:185:6: note: expected ‘int **’ but argument is of type ‘int (*)[(sizetype)(cols)]’
void fun1(int **, int rows, int cols);
Wir können auf verschiedene Arten reagieren, eine davon besteht darin, alles davon zu ignorieren und unleserliche Zeigerverknüppelungen durchzuführen:
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int (*)[], int rows, int cols);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(array_2D, rows, cols);
exit(EXIT_SUCCESS);
}
void fun1(int (*a)[], int rows, int cols)
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, *( (*a) + (i * cols + j)));
}
}
}
Oder wir machen es richtig und geben die benötigten Informationen an fun1 . Dazu müssen wir die Argumente in fun1 : Die Größe der Spalte muss vor der Deklaration des Arrays liegen. Um die Lesbarkeit zu verbessern, hat die Variable, die die Anzahl der Zeilen enthält, ebenfalls ihren Platz geändert und ist jetzt der erste.
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int rows, int cols, int (*)[]);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(rows, cols, array_2D);
exit(EXIT_SUCCESS);
}
void fun1(int rows, int cols, int (*a)[cols])
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Dies scheint einigen Leuten unangenehm zu sein, die der Meinung sind, dass die Reihenfolge der Variablen keine Rolle spielen sollte. Das ist kein großes Problem, deklarieren Sie einfach einen Zeiger und lassen Sie ihn auf das Array zeigen.
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int rows, int cols, int **);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
// a "rows" number of pointers to "int". Again a VLA
int *a[rows];
// initialize them to point to the individual rows
for (i = 0; i < rows; i++) {
a[i] = array_2D[i];
}
fun1(rows, cols, a);
exit(EXIT_SUCCESS);
}
void fun1(int rows, int cols, int **a)
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Verwenden von flachen Arrays als 2D-Arrays
Die einfachste Lösung besteht oft darin, 2D- und höhere Arrays als flachen Speicher zu übergeben.
/* create 2D array with dimensions determined at runtime */
double *matrix = malloc(width * height * sizeof(double));
/* initialise it (for the sake of illustration we want 1.0 on the diagonal) */
int x, y;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
if (x == y)
matrix[y * width + x] = 1.0;
else
matrix[y * width + x] = 0.0;
}
}
/* pass it to a subroutine */
manipulate_matrix(matrix, width, height);
/* do something with the matrix, e.g. scale by 2 */
void manipulate_matrix(double *matrix, int width, int height)
{
int x, y;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
matrix[y * width + x] *= 2.0;
}
}
}