2D Arrays und Zugriff über Pointer?

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.

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

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

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.

nein, du kannst doch in einem typedef nichts intialisieren.

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

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 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.