Daten aus array holen

[Felix (Gast)]

Hallo,
ich habe eine Funktion, die einen Array und die länge des Arrays als 
Parameter erhält.
Im Array stehen Daten die ich auswerten möchte.
Ich hole mir direkt am Anfang der Funktion die Daten aus dem Array.
Wenn ich alle daten geholt habe, überprüfe ich diese. Unter anderem auch 
die Länge. Wenn die Länge nicht stimmt, gebe ich eine Fehlermeldung aus.

Meines wissens nach, sollte es so keine Probleme geben. Wenn der Array 
nur 3 werte hat und ich mir den 5 wert hole, steht da halt irgendwas 
drinn. Es kommt aber nicht zu einem Absturz oder ähnlichem.
Ist das richtig?
Oder ist es besser wirklich erst die Länge zu überprüfen und dann die 
Daten holen?

[Nachdenklicher (Gast)]

So lange du nur lesend zugreifst und Dir bewußt bist, daß Du bei den 
Elementen die "hinter" dem Ende liegen, Mist stehen hast, ist das 
normalerweise unproblematisch. Außer Du bist auf einer Plattform, die 
das abfängt und darauf irgendwie reagiert...

[Sebastian S. (amateur)]

Wie kann man, wenn das Array und dessen Länge bekannt sind, hinter das 
Teil grapschen?

Übrigens: Die Werte hinter dem Array können auch richtig "aussehen", 
sind es aber nicht.
So Du also in das Nirwana grabscht, gibt es keine vernünftige 
Möglichkeit, dies zu überprüfen.

[Rolf M. (rmagnus)]

Nachdenklicher schrieb:
> So lange du nur lesend zugreifst und Dir bewußt bist, daß Du bei den
> Elementen die "hinter" dem Ende liegen, Mist stehen hast, ist das
> normalerweise unproblematisch.

Das ist es normalerweise, aber allgemein ist es trotzdem in C verboten. 
Und das gilt nicht nur für den Zugriff, sondern sogar schon für das 
reine Erzeugen des Zeigers. Pointer-Arithmetik ist nur innerhalb des 
Arrays oder ein Element hinter dessen Ende erlaubt. Ein Element hinter 
dem Ende ist dabei aber nur für die Pointer-Arithmetik erlaubt, nicht 
für den Zugriff.

[Random .. (thorstendb)]

Für Datenstrukturen mit variabler Länge empfiehlt sich ein struct:

struct foo {
  uint16_t size;
  uint16_t type;
  uint8_t* buf;
};

[Arno (Gast)]

Nachdenklicher schrieb:
> So lange du nur lesend zugreifst und Dir bewußt bist, daß Du bei
> den
> Elementen die "hinter" dem Ende liegen, Mist stehen hast, ist das
> normalerweise unproblematisch. Außer Du bist auf einer Plattform, die
> das abfängt und darauf irgendwie reagiert...

Eigentlich sollte das jedes halbwegs moderne Betriebssystem der letzten 
ca. 25 Jahre tun, zumindest wenn man hinreichend weit hinter dem Ende 
des Arrays zugreift und dabei die für das Programm legalen 
Speicherbereiche verlässt (wir sind hier ja im Unterforum 
PC-Programmierung, auf µCs ohne Betriebssystem sieht das idR anders 
aus).

(Erzeugt dieses Verhalten nicht unter Windows 95 die berühmte 
"Allgemeine Schutzverletzung"?)

Wenn man nur zwei Bytes hinter das Array greift, hat man aber gute 
Chancen, dass man noch nicht aus dem Speicherbereich des Programms 
hinaus gelaufen ist. Probier es halt aus:

char buffer[20];

void tuWas(char * mBuffer, int length)
{
  char a = mBuffer[20+2];
}

int main(void)
{
  tuWas(buffer, 20);
}

Oder sprichst du von einem großen Array, in dem du nur die ersten 
Speicherstellen beschreibst? Also:

char buffer[20];

void tuWas(char * mBuffer, int length)
{
  char a = mBuffer[18];
}

int main(void)
{
  buffer[0] = 'a';
  buffer[1] = 'b';
  buffer[2] = 'c';
  tuWas(buffer, 3);
}

Das ist unproblematisch (solange du weißt, dass du zufällige Werte liest 
und solange die Längen alle zusammenpassen).

MfG, Arno

[M.K. B. (mkbit)]

Arno schrieb:
> Wenn man nur zwei Bytes hinter das Array greift, hat man aber gute
> Chancen, dass man noch nicht aus dem Speicherbereich des Programms
> hinaus gelaufen ist. Probier es halt aus:

Ausprobieren gibt aber keine Garantie, dass es immer so funktioniert.

Beispiel Mikrocontroller ohne Memory Protection. Ich kann im Speicher 
auf beliebige Adressen zugreifen, aber halt nur im Speicher. Liegt mein 
Array jetzt zufällig am Ende des Speichers, dann geht es plötzlich nicht 
mehr.

Deshalb ist der Zugriff außerhalb von Datenstrukturen auch undefined.

[GEKU (Gast)]

Ich würde die Zugriff in der Funktion auf jeden Fall überwachen, den 
Wert über Zeiger (called by reference)  zurück liefern und den 
Retourwert der Funktion für die Erfolgsmeldung verwenden. Nur so ist 
eine weitere Fehlerbehandlung möglich.