ATMega8: Pointer auf int32_t Array

[Frank (Gast)]

Hallo,

ich möchte in einer Unterfunktion ein Array aus 32 Bit Integer Werten 
verarbeiten.

In 8 Bit würde ich das ja wie folgt machen:

void funktion(int8_t* tmpwert){
   (int8_t)*(tmpwert)++;     //für tmpwert[0]
   (int8_t)*(tmpwert+1)++;   //für tmpwert[1]
   (int8_t)*(tmpwert+2)++;   //für tmpwert[2]
}


//Aufruf mit

int8_t wert[3]={0,0,0};

//...

funktion(&wert);

Muss ich beim Zugriff auf einen 32 bit Integer die Pointer für tmpwert 
um eins oder um vier erhöhen um auf tmpwert[1] zu kommen?


Danke & Gruß

Frank

[Frank (Gast)]

Oh Gott. -.-

[Cyblord -. (cyblord)]

Ein Pointer wird immer um eine ganze Länge addiert. Bei einem 32 Bit 
Pointer also automatisch um 4 Bytes.

[Peter II (Gast)]

Frank schrieb:
> ich möchte in einer Unterfunktion ein Array aus 32 Bit Integer Werten
> verarbeiten.

dann verwende doch auch ein array von int32. ich sehe in deinem code 
aber überhaupt kein int32?

[Rufus Τ. F. (rufus)]

Frank schrieb:
> In 8 Bit würde ich das ja wie folgt machen:void funktion(int8_t*
> tmpwert){
>    (int8_t)*(tmpwert)++;     //für tmpwert[0]
>    (int8_t)*(tmpwert+1)++;   //für tmpwert[1]
>    (int8_t)*(tmpwert+2)++;   //für tmpwert[2]
> }

Und warum so ... überaus umständlich?

Warum nicht ganz einfach so?

void funktion(int8_t* tmpwert){
  tmpwert[0]++;
  tmpwert[1]++;
  tmpwert[2]++;
}

Dann sollte auch klarwerden, wie das ganze aussieht, wenn das Array 
einen anderen Datentyp hat. Nämlich ... genauso.

[Cyblord -. (cyblord)]

Ja der Beispielcode ist echt unglücklich. Keine Ahnung was der soll, 
lass den weg und schreib doch bitte direkt mit 32 Bit Datentypen hin was 
du tun willst. So verwirrt das.

[Frank (Gast)]

Sorry, dass ich mich schlecht ausgedrückt habe...

in 32 bit wäre der Code dann so

void funktion(int32_t* tmpwert){
   (int32_t)*(tmpwert)++;     //für tmpwert[0]
   (int32_t)*(tmpwert+1)++;   //für tmpwert[1]   oder +4?
   (int32_t)*(tmpwert+2)++;   //für tmpwert[2]   oder +8?
}


//Aufruf mit

int32_t wert[3]={0,0,0};

//...

funktion(&wert);

Ich kann nciht direkt drauf zugreifen, weil ich je nach Fall auf 
unterschiedliche arrays zugreifen möchte...

Insgesamt wird das ganze ein IIR Filter für mehrere Kanäle...

[Fred (Gast)]

Himmel hilf, was für ein Unsinn!
Unnötige Casts, unnötige Pointerarithmetik, fehlerhafte Übergabe mit 
Adressderefenzierung ...

[Peter II (Gast)]

sollte doch einfach so gehen:

void funktion(int32_t* tmpwert){
   tmpwert[0]++;     //für tmpwert[0]
   tmpwert[1]++;   //für tmpwert[1]   oder +4?
   tmpwert[2]++;   //für tmpwert[2]   oder +8?
}

oder habe ich was übersehen?

[Fred (Gast)]

void funktion(int32_t* tmpwert){
   tmpwert[0]++;
   tmpwert[1]++;
   tmpwert[2]++;
}


//Aufruf mit

int32_t wert[3]={0,0,0};

//...

funktion(wert);

[Karl H. (kbuchegg)]

Frank schrieb:

>

> void funktion(int32_t* tmpwert){
>    (int32_t)*(tmpwert)++;     //für tmpwert[0]
>    (int32_t)*(tmpwert+1)++;   //für tmpwert[1]   oder +4?
>    (int32_t)*(tmpwert+2)++;   //für tmpwert[2]   oder +8?
> }
> 
> 
> //Aufruf mit
> 
> int32_t wert[3]={0,0,0};
> 
> //...
> 
> funktion(&wert);
>

Und warum so kompliziert?
tmpwert ist doch schon ein POinter auf eine 32-Bit Einheit. Wozu da noch 
lange rumcasten?

Schreibs einfach so wie vorgeschlagen

void funktion(int32_t* tmpwert){
   tmpwert[0]++;
   tmpwert[1]++;
   tmpwert[2]++;
}

und guts ists?

AUf der einen Seite wird immer geschrieen, dass C so kompliziert wäre. 
Dann gibt es mal eine einfache Schreibweise und keiner will sie 
benutzen.

> Ich kann nciht direkt drauf zugreifen, weil ich je nach Fall auf
> unterschiedliche arrays zugreifen möchte...

Und?
Was hat das damit zu tun.
Du übergibst ja die Adresse des Arrays an die Funktion. Passt doch!


Du brauchst ganz dringend ein C-Buch und solltest so ungefähr die erste 
Hälfte durcharbeiten, ehe du dich an reale Programme wagst. Das hat doch 
keinen Sinn, wenn du von deinem 'Werkzeug' 60% nicht verstehst wie das 
funktioniert.

[Falk B. (falk)]

@ Frank (Gast)

>in 32 bit wäre der Code dann so

>void funktion(int32_t* tmpwert){
>   (int32_t)*(tmpwert)++;     //für tmpwert[0]
>   (int32_t)*(tmpwert+1)++;   //für tmpwert[1]   oder +4?
>   (int32_t)*(tmpwert+2)++;   //für tmpwert[2]   oder +8?
>}

+1 stimmt schon, denn der Compiler rechnet immer vom Pointer zur 
physikalischen Adresse um. Wenn du aus int32 zeigst, witrd er immer 
+X*sizefo(int32) rechnen.


>Ich kann nciht direkt drauf zugreifen, weil ich je nach Fall auf
>unterschiedliche arrays zugreifen möchte...

Die aber alle von gleichen Typ sein müssen, sonst wird es umständlich, 
da müsste man sizof(type) als Parameter übergeben.