Array in Array

[Alex R. (itaxel)]

Hallo zusammen,

ich möchte mehrere 2d-Arrays in einem Array für einen dynamischen 
Zugriff ablegen.

static const int** _fontdesc[] = {
  microsoftSansSerif_8ptDescriptors,
  microsoftSansSerif_10ptDescriptors
};

Die Arrays in _fontdesc sind 2d-Arrays.

Beim compilieren kommt folgende Fehlermeldung:

error: cannot convert 'const int (*)[2]' to 'const int**' in initialization

sitze seit Stunden davor und lese und recherchiere und bekomme es nicht 
hin. :(

Mit eindimensionalen Arrays funktioniert es:

static const char* _fonttype[] = {
  microsoftSansSerif_8,
  microsoftSansSerif_10
};

Kann mir da jemand weiter helfen?

Gruß Alex

[Daniel A. (daniel-a)]

Wozu benötigst du denn die zusätzliche indirection? 
microsoftSansSerif_8ptDescriptors hat eben eine weniger.

[nfet (Gast)]

Das liegt daran, dass Arrays und Zeiger eben nicht ganz dasselbe sind.

    static const int** _fontdesc[] = {
        (const int**) microsoftSansSerif_8ptDescriptors,
        (const int**) microsoftSansSerif_10ptDescriptors
    };

Das würde funktionieren. Kommt drauf an, was du dann noch vorhast mit 
_fontdesc. Denn der Zugriff darauf ist jetzt nicht mehr so cool.

Wenn es dir aber reichen würde immer nur einen Zeiger auf das erste 
Element im Array zu speichern, dann ist das viel leichter gemacht und 
sieht auch nicht so seltsam aus.

    static const int _fontdesc[] = {
        &microsoftSansSerif_8ptDescriptors[0][0],
        &microsoftSansSerif_10ptDescriptors[0][0]
    };

Ich muss auch zugeben, dass der Zusammenhang zwischen Arrays und Zeigern 
sehr verwirrend ist und ich daher für nichts eine Garantie übernehme.

Wenn es noch jemand besser weiß, dann bin ich daran auch sehr 
interessiert.

[nfet (Gast)]

    int foo0[2][2] = {{1,2},{3,4}};
    int foo1[2][2] = {{5,6},{7,8}};

    int* listeDerArrays[2][2];
    *listeDerArrays[0] = (int*)foo0;
    *listeDerArrays[1] = (int*)foo1;

    // Zugriff mit:
    listeDerArrays[1][0][1];

Hat mir keine richtige Ruhe gelassen, von daher hier noch eine Lösung

[Daniel A. (daniel-a)]

Du willst also foo0[1][1] mit listeDerArrays[0][0][3] ansprechen?

[Alex R. (itaxel)]

nfet schrieb:
> Das liegt daran, dass Arrays und Zeiger eben nicht ganz dasselbe sind.
>     static const int** _fontdesc[] = {
>         (const int**) microsoftSansSerif_8ptDescriptors,
>         (const int**) microsoftSansSerif_10ptDescriptors
>     };
> Das würde funktionieren. Kommt drauf an, was du dann noch vorhast mit
> _fontdesc. Denn der Zugriff darauf ist jetzt nicht mehr so cool

Diese Lösung hat mich schon mal ohne Fehlermeldung weiter gebracht. 
Allerdings bekomme ich beim außlesen ganz andere Werte als enthalten 
sind.

Mein microsoftSansSerif_8ptDescriptors sieht wie folgend aus:

static const int microsoftSansSerif_8ptDescriptors[][2] = {
   {1, 0},
   {4, 12},
   {6, 24}
}

wenn ich mir dann den ersten Wert ausgeben lasse kommt keine 1 sondern 
148 rauß

char myChar = "!";
int charASCII = (int)myChar - 33; // charASCCII = 0
int fontfamily = 0; // msSansSerif 8pt

const int charWidth = _fontdesc[fontfamily][charASCII][0];

Ausgabe von charWidth ist 148 ???

[Alex R. (itaxel)]

Korrektur:

char myChar = "!";

soll natürlich so sein:

char myChar = '!';

[Daniel A. (daniel-a)]

Alex R. schrieb:
> Allerdings bekomme ich beim außlesen ganz andere Werte als enthalten
> sind.

Das liegt am Speicherlayout von mehdimensionalen Arrays und dem falschen 
cast "(const int**) microsoftSansSerif_8ptDescriptors,"

2d Arrays sind im Speicher wie 1d Arrays abgelegt. Der cast kann daraus 
nicht magisch Pointer auf 1d arrays machen, weil diese Pointer nirgens 
gespeichert sind.

Folgende Möglichkeiten:
Array von Pointern auf Mehrdimensionale Arrays: (nearest match)

static const int (*_fontdesc[][2])[] = {
  microsoftSansSerif_8ptDescriptors
};

Möglichkeit 2, compound literal abuse: (worst option)

static const int** _fontdesc[] = {
  (const int*[]){
    microsoftSansSerif_8ptDescriptors[0],
    microsoftSansSerif_8ptDescriptors[1],
    microsoftSansSerif_8ptDescriptors[2]
  }
};

Möglichkeit 3, stattdessen structs verwenden: (best option)

typedef struct fontCharacterDescriptor {
  int charWidth, whatever;
} fontCharacterDescriptor_t;

static const fontCharacterDescriptor_t microsoftSansSerif_8ptDescriptors[] = {
   {1, 0},
   {4, 12},
   {6, 24}
};
static fontCharacterDescriptor_t (*_fontdesc[])[] = {
  microsoftSansSerif_8ptDescriptors
};

[Alex R. (itaxel)]

Hallo Daniel,

vielen Dank für deine Antwort. Das hat mir weiter geholfen.
Hätte nicht gedacht das ich mich an sowas mal aufhängen würde.

Gruß Alex

[Karl H. (kbuchegg)]

Daniel A. schrieb:

> Möglichkeit 3, stattdessen structs verwenden: (best option)

Was darüber hinaus auch noch öfter weiter hilft, das sind ein paar 
typedefs, mit denen man sich 'Abkürzungen' schafft. Man sieht sie für 
Arrays eher selten, aber sie können auch da recht nützlich sein, um die 
Syntax für darauf aufbauende weitere Datentypen zu entschärfen.