2D Arrays und Zugriff über Pointer?

[Frank Sotter (Gast)]

Hallo,
ich hab mal ne Frage zur Verwendung von Pointer im Zusammenhang mit 
2D-Arrays!
Ich hab da ein bißchen im angefügten C-file geschrieben!
Ich möchte quasi:

  if (d1 == &d1_buf2[len_max_short]) {
    mach' was;
  }

in das hier überführen:

  if (d1 == &d1_buf[2][len_max_short]) {
    mach' was;
  }

wobei "len_max_short die maximale Länge vom 2ten Element von "d1_buf" 
ist!

[Daniel (Gast)]

Was ist denn jetzt die Frage?  :-D

[Karl H. (kbuchegg)]

Vielleicht gehts nur mir so.
Aber ich hab nicht den leisesten Schimmer einer Ahnung, was du 
eigentlich willst und warum der ordinäre Adress Of Operator nicht gut 
genug ist.

[Frank Sotter (Gast)]

Daniel schrieb:
> Was ist denn jetzt die Frage?  :-D

Ähm oh man ging das nicht hervor!
Hmmmh also kurz gesagt:

Ich brauche ein 2D Array aus
z.B.
array[8][] und der zweite Parameter hat unterschiedliche Längen!
also
achso hier ist der erste Index wirklich der Index ;)
und der zweite die jeweils gewünschte Länge?
array[0][2]
array[1][4]
array[2][8]
array[3][16]
array[4][32]
array[5][64]
array[6][128]
array[7][256]

geht so was steh gerad auf Schlauch?

[Michael W. (mt1)]

Das geht nicht.
Du willst das dein Array so aussieht

  m
n x - x - x - x - x - x - x - x
  x - x - x - x - x - x - x - x
  x - x - x - x - x - x - x - x
  x - x -   - x - x - x - x - x
  x - x -   - x - x -   - x - x
    - x -   - x - x -   - x - x
    - x -   - x - x -   - x - x
    - x -   -   - x -   - x - x
    - x -   -   - x -   - x - x
    - x -   -   -   -   - x - x

Aber bei der Deklaration legst du schon fest dass dein Array eine n x m 
Matrix aufweist.

Bsp.:
<type> <name>[n][m];
int array1[8][4];
  m
n x - x - x - x - x - x - x - x
  x - x - x - x - x - x - x - x
  x - x - x - x - x - x - x - x
  x - x - x - x - x - x - x - x

[2D (Gast)]

char arr1[2];
char arr2[33];
char arr3[111];
char arr4[44];

char* arrArr[] = {arr1, arr2, arr3, arr4};

char foo (void) {
  return (arrArr[2][22];
}

mal was zum Zerreissen ;-)

[Dennis H. (c-logic)]

Im Endeffekt Pointer-Array welches Pointer auf z.B. vordefinierte Arrays 
hat.

#define BUF4 2

short d1_buf4[BUF4*2]={1,2}, d2_buf4[BUF4*2]={2,3},
      d3_buf4[BUF4*2]={4,5}, d4_buf4[BUF4*2]={6,7},
      d5_buf4[BUF4*2]={8,9}, d6_buf4[BUF4*2]={10,11},
      d7_buf4[BUF4*2]={12,13},
      d8_buf4[BUF4*13]={14,15,16,17,18,19,20,21,22,23,24,25,26};

short* buf4[]={ d1_buf4,d2_buf4,d3_buf4,d4_buf4,
                d5_buf4,d6_buf4,d7_buf4,d8_buf4};

int main()
{
    printf("%i",buf4[2][1]);
    return 0;
}

[Klaus W. (mfgkw)]

Ja, wenn ich die (etwas wirre) Frage richtig verstanden habe, sieht so 
etwa die Antwort aus.

Aber:

Frank Sotter schrieb:
> if (d1 == &d1_buf[2][len_max_short]) {
>     mach' was;
>   }
>
> wobei "len_max_short die maximale Länge vom 2ten Element von "d1_buf"
> ist!

Wenn das Feld in der ersten Dimension 2 Elemente hat, und in der zweiten 
len_max_short, dann darf der Index nur bis 2-1 bzw. len_max_short-1 
gehen! Es fängt ja jeweils bei 0 an zu zählen.
d1_buf[2][len_max_short] ist also eine Feldgrenzenüberschreitung.

[Frank Sotter (Gast)]

Ok ich hab jetzt mal nen neuen Versuch gemacht!

Also ich hab in der angefügten Datei versucht ein struct zu erstellen!
Ist das so richtig? bzgl. Indizes etc.?

[Klaus W. (mfgkw)]

nein, du kannst doch in einem typedef nichts intialisieren.

Das hätte dir dein Compiler auch sagen können.

[Karl H. (kbuchegg)]

ICh werd das Gefühl nicht los, dass hier versucht wird ein Problem mit 
untauglichen Mítteln zu lösen. Und anstelle das man das Problem 
attackiert, fragt man sich wie man die untauglichen Mitteln dem Compiler 
unterjubeln könnte.

[Frank Sotter (Gast)]

Ok mir ist jetzt klar was ich brauche:

Und zwar brauche ich ein Array wie folgt:

z.B.

float array[8][8][variable] also

die letzte Dimension des Arrays ist unterschiedlich lang?

also
array[0][0][]={2,3};
array[0][1][]={2,3};
array[0][2][]={2,3};
array[0][3][]={2,3};
array[0][4][]={2,3};
array[0][5][]={2,3};
array[0][6][]={2,3};
array[0][7][]={2,3,4,5,6,7,8,9,10,11,12,13,14};

array[1][0][]={2,3,2,3};
array[1][1][]={2,3,2,3};
array[1][2][]={2,3,2,3};
array[1][3][]={2,3,2,3};
array[1][4][]={2,3,2,3};
array[1][5][]={2,3,2,3};
array[1][6][]={2,3,2,3};
array[1][7][]={2,3,4,5,6,7,8,9,10,11,12,13,14,2,3,4,5,6,7,8,9,10,11,12,1 
3,14};
.
.
.
etc.

wie kann man so was machen ? schließlich möchte ich dann per Index auf 
ein Element zugreifen?

[Karl H. (kbuchegg)]

Frank Sotter schrieb:
> Ok mir ist jetzt klar was ich brauche:
>
> Und zwar brauche ich ein Array wie folgt:
>
> z.B.
>
> float array[8][8][variable] also
>
> die letzte Dimension des Arrays ist unterschiedlich lang?

Indem du die 'letzte Dimension' nicht als Arrayindex auffasst, sondern 
ein 8*8 Array von Pointern anlegst. An jeden Pointer allokierst du dann 
dynamisch ein float Array mit der gewünschten Größe.

Aufpassen: Das ist Vorstellungsmässig nicht das, was dir vorschwebt, 
aber es implementiert dein gewünschtes Verhalten. Und es unterscheidet 
sich syntaktisch in der Verwendung nicht von einem echten 3D Array .. 
sprich: du greifst nach wie vor mittels Array-Indexierung auch auf die 
letzte Dimension zu.


Am Beispiel 2D-Array, wobei die letzte Dimension variabel sein soll

int* Data[5];

   Data[0] = malloc( 2 * sizeof(**Data));   // Allokiere 2 Elemente
   Data[0][0] = 8;
   Data[0][1] = 3;

   Data[1] = malloc( 4 * sizeof(**Data));   // jetzt 4
   Data[1][0] = 2;
   Data[1][1] = 4;
   Data[1][2] = 5;
   Data[1][3] = 27;

...


Was du in Wirklichkeit damit aufgebaut hast, sieht im Speicher so aus

  Data
  +------+          +---+---+
  |  o------------->| 8 | 3 |
  +------+          +---+---+
  |  o--------+
  +------+    |          +---+---+---+---+
  |      |    +--------->| 2 | 4 | 5 | 27|
  +------+               +---+---+---+---+
  |      |
  +------+
  |      |
  +------+

es ist kein echtes 2D Array, denn bei dem würden die einzelnen Elemente 
im Speicher direkt hintereinander liegen. Das allerdings bedingt wieder, 
dass alle Zeilen gleich lang sind, und das ist nicht das was du 
(anscheinend) haben willst.

[Frank Sotter (Gast)]

Moin ich hab's glaube ich endlich geschafft.

siehe anghängte Datei!

ich kann nun das Array "stage"
über 3 Indizes ansprechen!!
also
stage[0][3[7] z.B.

jetzt kann ich mich an die nächste Aufgabe machen, die ich (in 
kompliziert schon gelöst habe;) !!)

Vielen Dank für die Inspiration allen die hier bis jetzt geschrieben 
haben

[2D (Gast)]

warum machst Du es so kompliziert, schau Dir das einemal in Ruhe an:
Beitrag "Re: 2D Arrays und Zugriff über Pointer?"

Das dürfte genau Deinen Bedarf decken.