Was wird hier gemacht?

[klaus (Gast)]

for (i = 0; i < 10 * 1024; ++i) {
         if (i & 1) {                              <- i und 1? wieso
             ptr[i] = 0x55AA55AA | (1 << i);       <- wieso?
         }
         else {
             ptr[i] = 0xAA55AA55 | (1 << i);
         }

[Bernd S. (soundgott)]

vielleicht wird's klarer wenn man
i & 0x01 schreibt
dämmert's ?

[Michael G. (linuxgeek)]

Das is ne Bitmaske

[Stefan K. (Gast)]

Sieht nach ziemlichen Schwachsinn aus. Ab dem 33 Durchlauf passiert dort 
nichts mehr, außer des Speicher vollgeschrieben wird.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Teil aus einem RAM-Test ?

[Uwe (Gast)]

(i & 1) dient einer Gerade oder Ungerade unterscheidung.

for (i = 0; i < 10 * 1024; ++i) {
         if (i & 1) {                              wenn i gerade
             ptr[i] = 0x55AA55AA | (1 << i);       dann das hier
         }
         else {
             ptr[i] = 0xAA55AA55 | (1 << i);       sonst das hier
         }

Aber da i ja als Maximalwert 10*1024=10240 erreichen kann denke ich das
"(1 << i);" nicht wirklich gut funktioniert. Eine Schiebeoperation um 
10240 Stellen ist sicherlich nicht von Erfolg gekrönt wenn danch mit 
einer 32 Bit Zahl eine Oder Operation durchgefüht wird.

[klaus (Gast)]

Außer null gilt die obere schleife und bei i=0 gilt die untere? oder 
wie?

[klaus (Gast)]

was passiert wenn ich i um 1 verschiebe?

[mitleser (Gast)]

Du musst fragen:
Was passiert wenn 1 um i verschiebe?

[klaus (Gast)]

Also mit if(1 & i) schaue ich ob gerade oder ungerade.
Und was macht
                     ptr[i] = 0x55AA55AA | (1 << i);

habe einen hänger grad.....

[thorstendb (Gast)]

Schachbrett-Test aus nem RAM check

[Kan a. (Firma: Basta) (kanasta)]

klaus schrieb:
> ptr[i] = 0x55AA55AA | (1 << i);

eine walking 1 auf einem Bitmuster (55=0101, AA=1010)

[Peter II (Gast)]

vermutlich müsste es so besser sein

 ptr[i] = 0x55AA55AA | ( 1 << (i%16) );

[Kan a. (Firma: Basta) (kanasta)]

warum 16? Ich würd da ja eher 32 nehmen...

[Peter II (Gast)]

Kan asta schrieb:
> warum 16? Ich würd da ja eher 32 nehmen...

ja ist vermutlich besser, da es hier um 32bit INTs geht.

[Kan a. (Firma: Basta) (kanasta)]

Hast wohl zu lange mit Megas rumprogrammiert, Peter ;)

[Michael S. (rbs_phoenix)]

Uwe schrieb:
> for (i = 0; i < 10 * 1024; ++i) {
>          if (i & 1) {                              wenn i gerade
>              ptr[i] = 0x55AA55AA | (1 << i);       dann das hier
>          }
>          else {
>              ptr[i] = 0xAA55AA55 | (1 << i);       sonst das hier
>          }

Wenn i = 1 bzw 2 ist:
Es wird bitweise und-Verknüpft, also :

   i=1         i=2
  0...001     0...010
& 0...001   & 0...001
---------   ---------
  0...001     0...000

Also, wenn i = 1 ist, kommt true raus und er geht ins if. Wenn i = 2 
ist, kommt 0 raus, also false, somit geht er "ins" else. Somit sind die 
"Kommentare" da oben falsch. Er geht ins if, wenn i ungerade ist und ins 
else, wenn i gerade ist.

[Kan a. (Firma: Basta) (kanasta)]

kann hier niemand C lesen. Wo bleibt Karl-Heinz?

Natürlich ist 1 ungerade.

[Karl H. (kbuchegg)]

Kan asta schrieb:
> kann hier niemand C lesen. Wo bleibt Karl-Heinz?

Grad in einer Besprechung.

Wurde doch schon mehr oder weniger alles gesagt.
Die Verwechslung 'gerade/ungerade' ordne ich mal unter 
'Implementierungsdetail' ein. Für das grundsätzliche Verständnis nicht 
so wichtig.