sizeof bei Array von Pointern auf Arrays

[Usus (Gast)]

Hallo,

ich habe ein const Array von Pointern auf andere const Arrays:

pArray[] = {Array1, Array2, Array3, Array4}

Zugriff auf Inhalte erfolgt problemlos über pArray[pIndex][Index].

Nun möchte ich vor dem Zugriff eine if-Abfrage einbauen, die 
sicherstellt dass die Grenzen (sowohl für das pArray als auch für die 
Zielarrays) nicht überschritten werden.

Mit

pIndex < (sizeof(pArray)/sizeof(Type_pArray))

kann ich das schonmal für das Zeiger-Array realisieren.

Wie aber kann ich dies für den Zielarray-Index machen?

Habe

Index < (sizeof(pArray[pIndex])/sizeof(Type_Array) versucht, aber da 
bekomme ich nur die Größe der Adresse raus, auf die das Element von 
pArray zeigt. Wie kann ich dem Compiler beibringen, dass sich hinter 
dieser Adresse ein Array verbirgt, dessen gesamte Größe ich wissen 
möchte?

Danke schonmal.

[Jörg W. (dl8dtl) (Moderator)]

Usus wrote:

> Wie kann ich dem Compiler beibringen, dass sich hinter
> dieser Adresse ein Array verbirgt, dessen gesamte Größe ich wissen
> möchte?

Gar nicht, diese Information musst du auf anderem Wege mitgeben, da
sie eben ein Pointer allein nicht transportieren kann.

[Usus (Gast)]

>Gar nicht, diese Information musst du auf anderem Wege mitgeben, da
>sie eben ein Pointer allein nicht transportieren kann.

Und auf welchem? sizeof kann ich ja keinen Parameter übergeben, der 
aussagt dass die Adresse ein Array ist.

[Stefan E. (sternst)]

Usus wrote:

> Und auf welchem?

Über zusätzliche Variablen/Parameter, wo die Größe direkt drinsteht.

Oder du terminierst deine Arrays einfach.

[Usus (Gast)]

>Über zusätzliche Variablen/Parameter, wo die Größe direkt drinsteht.

Da würden sich defines anbieten. Allerdings möchte ich eine generische 
Lösung, d.h. ich will die Arraynamen nicht hartcodiert verwenden sondern 
darauf eben nur über das Pointerarray zugreifen.

[Stefan E. (sternst)]

Dann erstelle doch ein zweites Array mit den dazugehörigen Größen:

??? pArray[] = {Array1, Array2, Array3, Array4};
unsigned int pArraySizes[] = ...

Oder du terminierst deine Arrays einfach.

[Jörg W. (dl8dtl) (Moderator)]

Oder ein Array aus Strukturen:

struct {
    foo_t *ary;
    size_t arysize;
} arrayofarray[] = ...

[Usus (Gast)]

>Dann erstelle doch ein zweites Array mit den dazugehörigen Größen:

Danke, das funktioniert. Somit kann ich alles über einen Header 
konfigurierbar halten, ist dann halt etwas mehr Aufwand wenn ein Array 
dazu kommt.

>Oder du terminierst deine Arrays einfach.

Du meinst einen Token ans Ende setzen, und dann in der if-Abfrage

pArray[pIndex][Index] != Token

abfragen?

[Norgan (Gast)]

Lösung Nr. 1:

Mach dir nicht die Mühe das zur Laufzeit zu testen. Sieh zu, dass die 
Felder einfach passen.

Lösung Nr. 2:

typedef struct {
   size_t  size;
   int *data;
} SizeArray;

SizeArray a = malloc(sizeof(SizeArray));
a.size = ANZAHL_ELEMENTE;
a.data = malloc(ANZAHL_ELEMENTE * sizeof(int));

Lösung Nr. 3:

int data[ANZAHL_ELEMENTE+1];
data[0] = ANZAHL_ELEMENTE;

Lösung Nr. 4: C++
Lösung Nr. 5: Embedded Java ME :-)

[Stefan E. (sternst)]

Usus wrote:

>>Oder du terminierst deine Arrays einfach.
>
> Du meinst einen Token ans Ende setzen, und dann in der if-Abfrage
>
> pArray[pIndex][Index] != Token
>
> abfragen?

Ja, ein Element, das sonst im Array nicht vorkommt, und damit eindeutig 
das Ende markiert, wie die Null bei Strings.
Aber: je nach dem, was "Element" konkret ist, kann das natürlich auch 
deutlich mehr Ressourcen verbrauchen.

[Stefan E. (sternst)]

Oh, noch was:
Das funktioniert natürlich nur gut bei Schleifen. Ich sehe gerade, dass 
du wohl eher einen wahlfreien Zugriff überprüfen möchtest. Da ist die 
Lösung nicht so gut, da du dann jedesmal das Array "durchgehen" musst, 
um die Größe zu ermitteln.