Adresse eines Arrayelement übergeben und diese dann inkrementieren

[Gast (Gast)]

Hallo,
ich möchte einer Funktion als Parameter die Adresse eines Arrayelements 
übergeben und ab dieser Stelle als weiteren Parameter n bytes schreiben. 
Alles nicht so schwer, nur das inkrementieren des Index macht mir 
Verständnisprobleme. Kann bzw. sollte man im Sinne von "guter 
Progammierstil"  davon ausgehen, daß alle Elemente eines Arrays in einem 
Stück mit aufsteigendem Index hintereinander im RAM liegen? Dann kann 
man ja bei bekannter Speicherbreite etwas rumrechnen (z.B. bei 
8-bit-Architektur soll ein 8-bit-Wert abgelegt werden => Adresse um 1 
erhöhen für nächsten Index, bei 16-bit-Wert Adresse um 2 erhöhen für 
nächsten Indexetc.). Das ganze ist natürlich nicht portabel und macht 
mir auch nicht den "vernünftigen" Eindruck. Wie macht man sowas 
vernüftig?

[Sven P. (Gast)]

Gast schrieb:
> Hallo,
> ich möchte einer Funktion als Parameter die Adresse eines Arrayelements
> übergeben und ab dieser Stelle als weiteren Parameter n bytes schreiben.
> Alles nicht so schwer, nur das inkrementieren des Index macht mir
> Verständnisprobleme. Kann bzw. sollte man im Sinne von "guter
> Progammierstil"  davon ausgehen, daß alle Elemente eines Arrays in einem
> Stück mit aufsteigendem Index hintereinander im RAM liegen?
Wenn wir von C reden, dann ist das so, ja.

> Dann kann
> man ja bei bekannter Speicherbreite etwas rumrechnen (z.B. bei
> 8-bit-Architektur soll ein 8-bit-Wert abgelegt werden => Adresse um 1
> erhöhen für nächsten Index, bei 16-bit-Wert Adresse um 2 erhöhen für
> nächsten Indexetc.). Das ganze ist natürlich nicht portabel und macht
> mir auch nicht den "vernünftigen" Eindruck. Wie macht man sowas
> vernüftig?
Am liebsten garnicht :-}
Wenn es wirklich sein muss, und das ist nicht oft, dann:
* mit sizeof arbeiten
* mit unions arbeiten und etwas Speicher verschenken
* Konzept überdenken

[Mark .. (mork)]

Gast wrote
> Dann kann
> man ja bei bekannter Speicherbreite etwas rumrechnen (z.B. bei
> 8-bit-Architektur soll ein 8-bit-Wert abgelegt werden => Adresse um 1
> erhöhen für nächsten Index, bei 16-bit-Wert Adresse um 2 erhöhen für
> nächsten Indexetc.).

Das macht der Compiler automatisch, man braucht den Zeiger also immer 
nur um 1 zu erhöhen, um zum nächsten Element zu kommen, egal wir groß 
ein Element ist.

MfG Mark

[Karl H. (kbuchegg)]

Gast schrieb:
> Wie macht man sowas
> vernüftig?

Vernünftig macht man sowas, indem man vorher irgendwann einmal ein 
C-Buch gelesen hat und sich daran erinnert, dass es da auch noch die 
Familie der mem...() Funktionen gibt, die man für alles was bytemässig 
behandelt werden soll, gut einsetzen kann.

[Lutz (Gast)]

Das Problem habe ich auch gerade, aber die Antworten scheinen in eine 
andere Richtung zu gehen => Mißverständnis?. Deshalb formuliere ich 
meine Frage mal an einem Beispiel:
Ich möchte einer Funktion eine Arrayadresse übergeben uns ab dieser 
Adresse n bytes ins Array schreiben (die Daten liegen NICHT in einem 
anderen Array vor; also kein mem...() möglich; sie werden über SPI aus 
einem externen Chipregister ausgelesen). Man kann natürlich auch die 
Startadresse des Arrays (=Arrayname) und den Index, ab dem geschrieben 
werden soll, in 2 separaten Parametern übergeben, also z.B.

void modify_array (uint8_t no_of_bytes, uint8_t *array[], uint8_t array_index)
{
   for (uint8_t i = 0, i < no_of_bytes, i++)
   {
      array[index] = "returniere irgendwie byte i aus Fremdchip";
      index++;
   }

Kann man das nicht in einen Schritt machen, also als Startadresse z.B. 
&(array[index]) übergeben? Nur wie inkrementiert mann dann diese 
Adresse? Etwa so?
(&array[index])++;

So langsam raucht mir der Schädel mit dem ganzen gepointere und den 
Arrays; Morgen sieht es vermutlich wieder sonnenklar aus.

[Stefan E. (sternst)]

Lutz schrieb:

> Nur wie inkrementiert mann dann diese Adresse?

array++;

Aber Vorsicht, deine Funktion hat da in der Parameterliste im Augenblick 
keinen Zeiger auf ein Byte-Array, sondern einen Zeiger auf ein Array aus 
Zeigern auf Bytes.