Übergabe eines Arrays mit unbekannter Größe an eine Funktion

Question

Angenommen, ich habe eine Funktion namens MyFunction(int myArray[][]), die Array-Manipulationen durchführt.

Wenn ich die Parameterliste so schreibe, wird der Compiler beschweren, dass er die Größe des Arrays zur Kompilierzeit kennen muss. Gibt es eine Möglichkeit, die Parameterliste umzuschreiben, sodass ich ein Array beliebiger Größe an die Funktion übergeben kann?

Die Größe meines Arrays wird durch zwei static const ints in einer Klasse definiert, aber der Compiler akzeptiert etwas wie MyFunction(int myArray[Board::ROWS][Board::COLS]) nicht.

Was ist, wenn ich das Array in einen Vektor konvertieren könnte und dann den Vektor an MyFunction übergebe? Gibt es eine Einzeilige Konvertierung, die ich verwenden kann, oder muss ich die Konvertierung manuell durchführen?

Answer 1

Der Compiler beschwert sich, weil er die Größe aller außer der ersten Dimension kennen muss, um ein Element im Array ansprechen zu können. Zum Beispiel im folgenden Code:

int array[M][N];
// ...
array[i][j] = 0;

Um auf das Element zuzugreifen, generiert der Compiler etwas Ähnliches wie folgt:

*(array+(i*N+j)) = 0;

Daher müssen Sie Ihre Signatur wie folgt neu schreiben:

MyFunction(int array[][N])

in diesem Fall bleiben Sie bei einer festen Dimension stecken oder Sie entscheiden sich für eine allgemeinere Lösung wie eine (benutzerdefinierte) dynamische 2D-Array-Klasse oder einen vector >.

Answer 2

Ja: MyFunction(int **myArray);

Aber Vorsicht. Du solltest besser wissen, was du tust. Dies akzeptiert nur ein Array von int-Zeigern.

Da du versuchst, ein Array von Arrays zu übergeben, benötigst du einen konstanten Ausdruck als eine der Dimensionen:

MyFunction(int myArray[][COLS]);

Du musst COLS zur Kompilierzeit haben.

Ich schlage vor, stattdessen einen Vektor zu verwenden.

Answer 3

1. Verwenden Sie einen vector > (das wäre Schummeln, wenn der zugrunde liegende Speicher nicht garantiert zusammenhängend wäre).

2. Verwenden Sie einen Zeiger auf das Element-of-Array (int*) und einen Größe (M*N) Parameter. Hier gibt es Drachen.

Answer 4

Zunächst sehen wir, warum der Compiler sich beschwert.

Wenn ein Array definiert ist als int arr[ ROWS ][ COLS ]; dann kann jegliche Array-Notation arr[ i ][ j ] in Pointer-Notation übersetzt werden als

*( arr + i * COLS + j )

Beachte, dass der Ausdruck nur COLS erfordert, nicht aber ROWS. Also kann die Array-Definition äquivalent geschrieben werden als

int arr [][ COLS ];

Aber, das Fehlen der zweiten Dimension ist nicht akzeptabel. Für etwas mehr Details, lies hier.

Nun zu deiner Frage:

Gibt es einen Weg, die Parameterliste neu zu schreiben, so dass ich ein Array beliebiger Größe an die Funktion übergeben kann?

Ja, vielleicht kannst du einen Zeiger verwenden, z.B. MyFunction( int * arr );. Aber überlege, wie würde MyFunction() wissen, wann es aufhören soll, auf das Array zuzugreifen? Um das zu lösen, bräuchtest du einen weiteren Parameter für die Länge des Arrays, z.B. MyFunction( int * arr, size_t arrSize );

Answer 5

tatsächlich wird die Größe meines Arrays durch zwei static const ints in einer Klasse definiert, aber der Compiler akzeptiert nicht etwas wie MyFunction(int myArray[Board::ROWS][Board::COLS]).

Das ist komisch, bei mir funktioniert es einwandfrei:

struct Board
{
    static const int ROWS = 6;
    static const int COLS = 7;
};

void MyFunction(int myArray[Board::ROWS][Board::COLS])
{
}

Vielleicht sind ROWS und COLS privat? Können Sie uns etwas Code zeigen?