Erstellen Sie einen Zeiger auf ein zweidimensionales Array

Ich brauche einen Zeiger auf ein statisches zweidimensionales Array. Wie wird das gemacht?

static uint8_t l_matrix[10][20];

void test(){
   uint8_t **matrix_ptr = l_matrix; //wrong idea 
}

Ich bekomme alle Arten von Fehlern wie:

• Warnung: Zuweisung vom inkompatiblen Zeigertyp
• indizierter Wert ist weder Feld noch ein Zeiger
• Fehler: Ungültige Verwendung des flexiblen Array-Mitglieds

Hier möchten Sie einen Zeiger auf das erste Element des Arrays erstellen

uint8_t (*matrix_ptr)[20] = l_matrix;

Mit typedef sieht das sauberer aus

typedef uint8_t array_of_20_uint8_t[20];
array_of_20_uint8_t *matrix_ptr = l_matrix;

Dann kannst du das Leben wieder genießen :)

matrix_ptr[0][1] = ...;

Hüten Sie sich vor der Zeiger- / Array-Welt in C, da herrscht große Verwirrung.

Bearbeiten

Überprüfen Sie einige der anderen Antworten hier, da die Kommentarfelder zu kurz sind, um sie dort auszuführen. Es wurden mehrere Alternativen vorgeschlagen, aber es wurde nicht gezeigt, wie sie sich verhalten. So machen sie es

uint8_t (*matrix_ptr)[][20] = l_matrix;

Wenn Sie den Fehler beheben und die Adresse des Operators &wie im folgenden Snippet hinzufügen

uint8_t (*matrix_ptr)[][20] = &l_matrix;

Dann erstellt dieser einen Zeiger auf einen unvollständigen Array-Typ von Elementen vom Typ Array von 20 uint8_t. Da sich der Zeiger auf ein Array von Arrays befindet, müssen Sie mit darauf zugreifen

(*matrix_ptr)[0][1] = ...;

Und weil es ein Zeiger auf ein unvollständiges Array ist, können Sie es nicht als Verknüpfung verwenden

matrix_ptr[0][0][1] = ...;

Da für die Indizierung die Größe des Elementtyps bekannt sein muss (die Indizierung impliziert das Hinzufügen einer Ganzzahl zum Zeiger, sodass dies bei unvollständigen Typen nicht funktioniert). Beachten Sie, dass dies nur funktioniert , in C, weil T[]und T[N]kompatible Typen sind. C ++ hat kein Konzept von kompatibelen Typen , und so ist es , dass Code ablehnen, weil T[]und T[10]verschiedene Arten sind.

Die folgende Alternative funktioniert überhaupt nicht, da der Elementtyp des Arrays, wenn Sie es als eindimensionales Array betrachten, dies nicht uint8_t istuint8_t[20]

uint8_t *matrix_ptr = l_matrix; // fail

Das Folgende ist eine gute Alternative

uint8_t (*matrix_ptr)[10][20] = &l_matrix;

Sie greifen mit darauf zu

(*matrix_ptr)[0][1] = ...;
matrix_ptr[0][0][1] = ...; // also possible now

Es hat den Vorteil, dass die Größe der äußeren Abmessung erhalten bleibt. Sie können also sizeof darauf anwenden

sizeof (*matrix_ptr) == sizeof(uint8_t) * 10 * 20

Es gibt eine andere Antwort, die die Tatsache nutzt, dass Elemente in einem Array zusammenhängend gespeichert werden

uint8_t *matrix_ptr = l_matrix[0];

Damit können Sie formal nur auf die Elemente des ersten Elements des zweidimensionalen Arrays zugreifen. Das heißt, die folgende Bedingung gilt

matrix_ptr[0] = ...; // valid
matrix_ptr[19] = ...; // valid

matrix_ptr[20] = ...; // undefined behavior
matrix_ptr[10*20-1] = ...; // undefined behavior

Sie werden feststellen, dass es wahrscheinlich funktioniert 10*20-1, aber wenn Sie Alias-Analysen und andere aggressive Optimierungen verwenden, könnte ein Compiler eine Annahme treffen, die diesen Code möglicherweise beschädigt. Trotzdem bin ich noch nie auf einen Compiler gestoßen, der darauf fehlschlägt (aber andererseits habe ich diese Technik nicht in echtem Code verwendet), und selbst in den C-FAQ ist diese Technik enthalten (mit einer Warnung über seine UB'ness) ), und wenn Sie den Array-Typ nicht ändern können, ist dies eine letzte Option, um Sie zu speichern :)

Um dies vollständig zu verstehen, müssen Sie die folgenden Konzepte verstehen :

Arrays sind keine Zeiger!

Erstens (und es wurde genug gepredigt) sind Arrays keine Zeiger . Stattdessen "zerfallen" sie in den meisten Fällen in die Adresse ihres ersten Elements, das einem Zeiger zugewiesen werden kann:

int a[] = {1, 2, 3};

int *p = a; // p now points to a[0]

Ich gehe davon aus, dass es so funktioniert, dass auf den Inhalt des Arrays zugegriffen werden kann, ohne alle zu kopieren. Das ist nur ein Verhalten von Array-Typen und soll nicht bedeuten, dass sie dasselbe sind.

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind nur eine Möglichkeit, den Speicher so zu partitionieren, dass der Compiler / die Maschine ihn verstehen und bearbeiten kann.

Zum Beispiel int a[4][3][5]= ein Array, das 4 * 3 * 5 (60) 'Chunks' von ganzzahligem Speicher enthält.

Der Vorteil gegenüber der Verwendung von int a[4][3][5]vs plain int b[60]besteht darin, dass sie jetzt "partitioniert" sind (bei Bedarf einfacher mit ihren "Chunks" zu arbeiten) und das Programm nun gebundene Überprüfungen durchführen kann.

Tatsächlich int a[4][3][5]wird genau wie int b[60]im Speicher gespeichert - Der einzige Unterschied besteht darin, dass das Programm es jetzt so verwaltet, als ob es sich um separate Entitäten bestimmter Größen handelt (insbesondere vier Gruppen zu drei Gruppen zu je fünf).

Denken Sie daran: Beide int a[4][3][5]und int b[60]sind im Speicher gleich, und der einzige Unterschied besteht darin, wie sie von der Anwendung / dem Compiler behandelt werden

{
  {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}
}

Daraus können Sie deutlich erkennen, dass jede "Partition" nur ein Array ist, das das Programm verfolgt.

Syntax

Jetzt unterscheiden sich Arrays syntaktisch von Zeigern . Dies bedeutet insbesondere, dass der Compiler / die Maschine sie unterschiedlich behandelt. Dies mag wie ein Kinderspiel erscheinen, aber sehen Sie sich Folgendes an:

int a[3][3];

printf("%p %p", a, a[0]);

Im obigen Beispiel wird dieselbe Speicheradresse zweimal wie folgt gedruckt:

0x7eb5a3b4 0x7eb5a3b4

Einem Zeiger kann jedoch nur einer so direkt zugewiesen werden :

int *p1 = a[0]; // RIGHT !

int *p2 = a; // WRONG !

Warum kann kein a Zeiger zugewiesen werden, kann es aber a[0] ?

Dies ist einfach eine Folge mehrdimensionaler Arrays, und ich werde erklären, warum:

Auf der Ebene von ' a' sehen wir immer noch, dass wir eine andere 'Dimension' haben, auf die wir uns freuen können. Auf der Ebene von ' a[0]' befinden wir uns jedoch bereits in der obersten Dimension, was das Programm betrifft, betrachten wir nur ein normales Array.

Sie fragen sich vielleicht:

Warum ist es wichtig, wenn das Array mehrdimensional ist, um einen Zeiger dafür zu erstellen?

Es ist am besten, so zu denken:

Ein "Zerfall" von einem mehrdimensionalen Array ist nicht nur eine Adresse, sondern eine Adresse mit Partitionsdaten (AKA versteht immer noch, dass die zugrunde liegenden Daten aus anderen Arrays bestehen), die aus Grenzen besteht, die vom Array über die erste Dimension hinaus festgelegt werden.

Diese 'Partitions'-Logik kann nicht innerhalb eines Zeigers existieren, es sei denn, wir geben sie an:

int a[4][5][95][8];

int (*p)[5][95][8];

p = a; // p = *a[0] // p = a+0

Andernfalls geht die Bedeutung der Sortiereigenschaften des Arrays verloren.

Beachten Sie auch die Verwendung von Klammern um *p: int (*p)[5][95][8]- Dies bedeutet, dass wir einen Zeiger mit diesen Grenzen erstellen, nicht ein Array von Zeigern mit diesen Grenzen:int *p[5][95][8]

Fazit

Lassen Sie uns überprüfen:

• Arrays zerfallen in Adressen, wenn sie im verwendeten Kontext keinen anderen Zweck haben
• Mehrdimensionale Arrays sind nur Arrays von Arrays. Daher trägt die "verfallene" Adresse die Last "Ich habe Unterdimensionen".
• Dimensionsdaten können in einem Zeiger nur vorhanden sein, wenn Sie sie ihm geben .

Kurz gesagt: Mehrdimensionale Arrays zerfallen in Adressen, die den Inhalt verstehen können.

Im

int *ptr= l_matrix[0];

Sie können gerne darauf zugreifen

*p
*(p+1)
*(p+2)

Immerhin werden zweidimensionale Arrays auch als 1-d gespeichert.

Tag auch,

Die Erklärung

static uint8_t l_matrix[10][20];

hat Speicher für 10 Zeilen mit 20 unit8_t-Positionen reserviert, dh 200 uint8_t-Positionen, wobei jedes Element durch Berechnung von 20 x Zeile + Spalte gefunden wird.

Also nicht

uint8_t (*matrix_ptr)[20] = l_matrix;

Geben Sie an, was Sie benötigen, und zeigen Sie auf das Element der Spalte Null in der ersten Zeile des Arrays.

Bearbeiten: Wenn Sie etwas weiter darüber nachdenken, ist ein Array-Name per Definition kein Zeiger? Das heißt, der Name eines Arrays ist ein Synonym für die Position des ersten Elements, dh l_matrix [0] [0]?

Edit2: Wie von anderen erwähnt, ist der Kommentarbereich für weitere Diskussionen etwas zu klein. Wie auch immer:

typedef uint8_t array_of_20_uint8_t[20];
array_of_20_uint8_t *matrix_ptr = l_matrix;

bietet keine Speicherzuweisung für das betreffende Array.

Wie oben erwähnt und wie in der Norm definiert, lautet die Aussage:

static uint8_t l_matrix[10][20];

hat 200 aufeinanderfolgende Speicherorte vom Typ uint8_t reserviert.

Verweis auf l_matrix unter Verwendung von Anweisungen der Form:

(*l_matrix + (20 * rowno) + colno)

gibt Ihnen den Inhalt des colno'ten Elements in Zeile rowno.

Bei allen Zeigermanipulationen wird automatisch die Größe des Objekts berücksichtigt, auf das verwiesen wird. - K & R Abschnitt 5.4, S.103

Dies ist auch der Fall, wenn eine Auffüllung oder Verschiebung der Byte-Ausrichtung an der Speicherung des vorliegenden Objekts beteiligt ist. Der Compiler passt diese automatisch an. Per Definition des C ANSI-Standards.

HTH

Prost,

In C99 (unterstützt von clang und gcc) gibt es eine obskure Syntax zum Übergeben mehrdimensionaler Arrays an Funktionen als Referenz:

int l_matrix[10][20];

void test(int matrix_ptr[static 10][20]) {
}

int main(void) {
    test(l_matrix);
}

Im Gegensatz zu einem einfachen Zeiger weist dies auf die Arraygröße hin, sodass der Compiler theoretisch vor dem Übergeben eines zu kleinen Arrays warnen und einen offensichtlichen Zugriff außerhalb der Grenzen erkennen kann.

Leider wird es nicht behoben sizeof()und Compiler scheinen diese Informationen noch nicht zu verwenden, so dass es eine Kuriosität bleibt.

Sie können jederzeit vermeiden, mit dem Compiler herumzuspielen, indem Sie das Array als linear deklarieren und die Berechnung des Array-Index (Zeile, Spalte) selbst durchführen.

static uint8_t l_matrix[200];

void test(int row, int col, uint8_t val)

{

   uint8_t* matrix_ptr = l_matrix;
   matrix_ptr [col+y*row] = val; // to assign a value

}

Das hätte der Compiler sowieso getan.

Die grundlegende Syntax zum Initialisieren des Zeigers, der auf ein multidimentionales Array verweist, lautet

type (*pointer)[1st dimension size][2nd dimension size][..] = &array_name

Die grundlegende Syntax für den Aufruf lautet

(*pointer_name)[1st index][2nd index][...]

Hier ist ein Beispiel:

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

int main() {
   // The multidimentional array...
   char balance[5][100] = {
       "Subham",
       "Messi"
   };

   char (*p)[5][100] = &balance; // Pointer initialization...

   printf("%s\n",(*p)[0]); // Calling...
   printf("%s\n",(*p)[1]); // Calling...

  return 0;
}

Ausgabe ist:

Subham
Messi

Es funktionierte...

Sie können es so machen:

uint8_t (*matrix_ptr)[10][20] = &l_matrix;

Sie möchten einen Zeiger auf das erste Element, also;

static uint8_t l_matrix[10][20];

void test(){
   uint8_t *matrix_ptr = l_matrix[0]; //wrong idea 
}

Sie können auch einen Offset hinzufügen, wenn Sie negative Indizes verwenden möchten:

uint8_t l_matrix[10][20];
uint8_t (*matrix_ptr)[20] = l_matrix+5;
matrix_ptr[-4][1]=7;

Wenn Ihr Compiler einen Fehler oder eine Warnung ausgibt, können Sie Folgendes verwenden:

uint8_t (*matrix_ptr)[20] = (uint8_t (*)[20]) l_matrix;