Farben nach R,G,B umwandeln in 4-stell. hex-code?

[Moppi]

s=(s<<1); dürfte Quatsch sein. s<<1 genügt und ist dasselbe, solange Variable s existiert. Wozu soll der nach s<<1 nochmal s=s ausführen? Korrigiere mich, wenn ich falsch liege!

[HaWe]

Ceos hatte Recht, es ist ein Unterschied, ich hatte es zuvor auch falsch vermutet. Zu Vergleichszwecken muss die Zuweisung in beiden Fällen gemacht werden, das macht dann im Ergebnis einen Unterschied zu vorher (s.o.), denn jetzt sind die Messwerte identisch nach beiden Methoden (vorher war ja fälschlich shiften schneller) !

[Moppi]

Ja, aber ich bin der Meinung, da wird was verwechselt.

s<<1; verschiebt Variable#S um 1 Bit nach links.

shl var_s,1

Bei Multiplikation (s=s*2)passiert was anderes. Ich denke in etwa so:

mov ax,var_s
mov bx,2
mul bx
mov var_s,ax

oder so:

mov ax,var_s
mul 2
mov var_s,ax

oder so, falls es möglich wäre:

mul var_s,2

Vom Prinzip her kommt es drauf an, was der Compiler für Maschinencode erzeugt.

Mit S=S<<1 machst Du in etwa so etwas:

mov ax,var_s
shl ax,1
mov var_s,ax

Das meine ich, ergibt keinen Sinn. Unnötige Operationen einzufügen. Wenn dann optimiert man einen Code, damit er schneller abgearbeitet wird. Und nicht, damit eine Befehlssequenz, die schneller ist, genau so schnell wird, wie eine andere, die langsamer ist.
Wichtig wäre zu wissen, ob s<<1 zum selben Ergebnis führt, wie s=s*2.

[HaWe]

interessanter Gesichtspunkt...
s ist ja immerhin volatile, also darf der Compiler diese Operation nicht wegoptimieren (was gpp sonst automatisch macht).
Dadurch wird das Shiften also keine Null- oder Leernummer.


Da müssen jetzt mal die hier einschlägig bekannten C/C++ Spezialisten etwas sagen...

- - - Aktualisiert - - -

habe jetzt mal den Mess-Code per Zusatz-Variable auf einen gemeinsamen Nenner gestellt:

long test_Int_multdiv2() {
  uint32_t  x,y;
  volatile uint32_t  s,t;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { t=s*2;}
    for(x=16; x>0;x--) { t=s/2;}
    s=7;
    for(x=1;x<=8;x++) { t=s*8;}
    for(x=8; x>0;x--) { t=s/8;}
  }
  return s;
}


long test_Int_shl_shr() {
  uint32_t  x,y;
  volatile uint32_t  s,t;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { t=(s<<1);}
    for(x=16; x>0;x--) { t=(s>>1);}
    s=7;
    for(x=1;x<=8;x++) { t=(s<<3);}
    for(x=8; x>0;x--) { t=(s>>3);}
  }
  return s;
}

auch hier: beide identisch!

ARM Cortex M0

start test
  0        93  Int_multdiv2
  1        93  Int_shl_shr

AVR (Mega2560)

start test
  0      1220  Int_multdiv2
  1      1220  Int_shl_shr

Fazit:
wenn einfach nur eine Variable erhöht werden soll, ist shiften schneller als Multipl./Division.

Wenn aber Werte zugewiesen und damit weiter gerechnet werden soll, sind beide gleich schnell, und das war ja hier die vorrangige Fragestellung

[Moppi]

wenn einfach nur eine Variable erhöht werden soll, ist shiften schneller als Multipl./Division.

Variable erhöhen: v=v+1 (bspw.: inc)
Multiplizieren mit 2: v=v*2 oder eben v=v<<1 (bspw.: shl)

Aber das ist ein ganz anderes Thema, gehört hier nicht mehr rein, denke ich.

[HaWe]

Spitzklicker!
auch durch Multiplikation oder shl wird die Variable aber erhöht, insb. im Sinne dieses Themas, und ich sprach ja nicht von "um 1 erhöhen".

[Moppi]

Erhöhe die Variable X um 5: X=X+5
Vervielfache Variable X, womit? -> mit 2: X=X*2

Bei der Multiplikation wird die Variable um ein Vielfaches erhöht, ja.

erhöhen: inkrementieren oder addieren
erniedrigen: dekrementieren oder subtrahieren
vervielfachen: multiplizieren oder anderes

Von mir aus aber auch nicht. Mach so wie Du denkst.