Schleife um Buffer zu füllen

[Hans (Gast)]

Hallo,
ich würde gerne einen Buffer mit abwechseln 1en und 0en füllen.

Geschrieben habe ich:

for (int i = 0; i<100;i+=2)
{
    buffer[i] = 0b11111111;
    fuffer[i+=1] = 0b00000000;
}

Ist das so richtig oder wo ist mein Fehler? Möchte das der Buffer immer 
weiter 1 und 0 im Wechsel ausgibt.

[Ausprobieren (Gast)]

Auch wenn das jetzt fies klingt...

Hast du es einfach mal ausprobiert?

[Mario M. (thelonging)]

Fehler über Fehler. Außerdem füllt Du den Buffer mit 255 und 0.

[Cyblord -. (cyblord)]

Außerdem werden zwei Buffer befüllt.

> fuffer[i+=1]

das gleichzeichen muss da weg

[Achim M. (minifloat)]

Hans schrieb:
> wo ist mein Fehler?

Da sind zwei Fehler:

Hans schrieb:
> fuffer[i+=1]

Probier mal buffer[i+1]

mfg mf

[Baffer (Gast)]

Hans schrieb:
> ich würde gerne einen Buffer mit abwechseln 1en und 0en füllen.

Byteweise gesehen oder bitweise gesehen? Bitweise wäre 0b01010101 als 
Wert für jedes Byte im Buffer, Byteweise wäre wiederholt 0b00000000 
gefolgt von 0b00000001 (bzw 0b11111111, dann wäre es aber abwechselnd 0 
und 255).
Der Ansatz hier sieht nach Byteweise aus, aber ich will nochmal sicher 
gehen. Wie ist denn die konkrete Fragestellung? (klingt sehr nach 
Hausaufgaben)


Die offensichtlichsten Fehler wären dass die Variable einmal buffer und 
einmal fuffer heißt und beim fuffer mit i+=1 indiziert wird, was den 
Wert von i verändert und an der Stelle höchstwahrscheinlich ungewollt 
ist.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Hans schrieb:
> ich würde gerne einen Buffer mit abwechseln 1en und 0en füllen.
Dann müsstest du den abwechselnd mit 0X55 und 0xAA füllen.

Ausprobieren schrieb:
> Hast du es einfach mal ausprobiert?
Eigentlich eine echt gute Idee.

[HildeK (Gast)]

Lothar M. schrieb:
> Dann müsstest du den abwechselnd mit 0X55 und 0xAA füllen.

Eher mit 0x55 ODER 0xAA, wenn man gedanklich die einzelnen Bytes 
hintereinander ausgeben würde ...

[Adam P. (adamap)]

Hans schrieb:
> Geschrieben habe ich:
>
> for (int i = 0; i<100;i+=2)
> {
>     buffer[i] = 0b11111111;
>     fuffer[i+=1] = 0b00000000;
> }

uint8_t buffer[100];
uint16_t *ptr;

ptr = (uint16_t *)buffer;

for (int i=0; i<50; i++)
{
   *ptr = 0x00FF;
   ptr++;
}

Auf einem 8-Bit System würde ich es jedoch einzeln befüllen.
Fehler wurden dir ja bereits aufgezeigt.

[Dirk B. (dirkb2)]

Adam P. schrieb:
> Auf einem 8-Bit System würde ich es jedoch einzeln befüllen.

Auf anderen Systemen auch.

buffer kann an einer ungeraden Adresse liegen und das mag nicht jeder 
16-Bit Zeiger

[Adam P. (adamap)]

Dirk B. schrieb:
> buffer kann an einer ungeraden Adresse liegen

Ich bin vom optimalen Fall ausgegangen.

Aber ja, dass sollte man ebenfalls beachten.

[Wolfgang (Gast)]

Hans schrieb:
> Ist das so richtig oder wo ist mein Fehler?

Nein

Du hast deine Variablen nicht deklariert und die Compilerfehlermeldungen 
nicht gelesen.

[Falk B. (falk)]

Hans schrieb:
> for (int i = 0; i<100;i+=2)
> {
>     buffer[i] = 0b11111111;
>     fuffer[i+=1] = 0b00000000;
> }

for (int i = 0; i<100; ) {
    buffer[i++] = 0b11111111;
    buffer[i++] = 0b00000000;
}

[Rolf M. (rmagnus)]

Dirk B. schrieb:
> Adam P. schrieb:
>> Auf einem 8-Bit System würde ich es jedoch einzeln befüllen.
>
> Auf anderen Systemen auch.
>
> buffer kann an einer ungeraden Adresse liegen und das mag nicht jeder
> 16-Bit Zeiger

Außerdem ist es systemabhängig, ob der buffer dann mit 0x00 oder mit 
0xFF anfängt.