Bit vertauschen

Nexus

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

volkard

Nexus schrieb:

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

Sharp oder IBM?
Manche machen auch nach jeder Zeile eine Leerzeile, außer da, wo ich statt der zwei zusammegehörenden Zeilen lieber bloß eine geschrieben hätte.

drakon

Nexus schrieb:

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

Ich finde oftmals ja. In einer Situation, wie oben muss man den Ausdruck eh recht genau anschauen, wenn man mit den Klammern nicht durcheinander kommen will, aber ich mache auch gerne Abstände, damit ich den Code nicht lesen, sondern nur anschauen muss. Wenn jetzt alles zusammen klebt übersehe ich leicht eine Klammer oder ein Zeichen o.ä.

Ich grupiere auch gerne Anweisungen, wie volkard anspricht. Jetzt nicht prinzipiell nach jeder Zeile ein Abstand, aber wenn ich 3-4 Aufrufe z.B auf das gleiche Objekt habe, dann kommen die nache zu einander, Leerzeile und das anderere Anweisungen.

foo.f ();
foo.bar ();
foo.foobar ();

baz.foo ();
baz.bar ();

Nexus

Natürlich ist es sinnvoll, Abstände zu benutzen. In meinen Augen tragen Whitespaces jedoch besonders dann zur Übersicht bei, wenn man sie unterschiedlich stark einsetzt.

(7*x - 3*y + 5) / (4*x + 5*y - 8)

Anweisungen zeilenweise gruppieren tue ich auch. Aber eben, auf diese Weise werden Newlines wieder mit Mass verwendet.

drakon schrieb:

foo.f ();
foo.bar ();
foo.foobar ();

baz.foo ();
baz.bar ();

da könntest doch auch schon fast über chaining nachdenken

foo.f().bar().foobar();
baz.foo().bar();

evtl. gehts auch nur so

foo->f()->bar()->foobar();
baz->foo()->bar();

Nexus

Es ginge schon beides, abhängig davon, ob eine Referenz oder ein Zeiger zurückgegeben würde.

Chaining ist im Grunde genommen eine interessante Technik, aber in vielen Fällen macht sie den Code nur noch unübersichtlicher. Denn weniger Zeilen ist nicht unbedingt besser.

image.set_size(22, 13).set_background_color(color::green).set_rotation(15.5f);
// vs.
image.set_size(22, 13)
image.set_background_color(color::green)
image.set_rotation(15.5f);

volkard

Test:

z = (7*x - 3*y + 5) / (4*x + 5*y - 8)

z = (7*x-3*y+5) / (4*x+5*y-8)

z=(7*x-3*y+5)/(4*x+5*y-8)

z= (7*x - 3*y + 5) 
   /
   (4*x + 5*y - 8)

also den größten flächeninhalt hat das letzte

Nexus

Kompromiss?

z = (7*x - 3*y + 5) 
  / (4*x + 5*y - 8);

Aber das mache ich eigentlich eher selten. Kommt ja auch nicht allzu häufig vor, dass man Teilausdrücke einander so schön zuordnen kann. Was ich manchmal bei komplexeren Ausdrücken mache:

foo.bar(
    vector2(
        32.5f + random(-4.f, 4.f) - 25.8f*foo.bir(),
        66.7f),
    124.4f - random(3.f, 7.f)/foo.bor(),
    "a string");

Ich muss allerdings gestehen, dass ich Abstände bei verschiedenen Operatoren nicht immer ganz strikt handhabe. Ich habe diesbezüglich noch kein Optimum gefunden, das man verallgemeinern könnte.

foo.bar(
    vector2(
        32.5f+random(-4.f,4.f)-25.8f*foo.bir()
       ,66.7f
    )
    ,124.4f-random(3.f,7.f)/foo.bor()
    ,"a string"
);

drakon

Chaining kann man machen, aber das macht imo nur dort Sinn, wo von einer Klasse wirklich ein solchen sehr intensives benutzen von einfachen Funktionen erwartet wird. (Hab das mal bei einer HTML Klasse oder so gesehen).

Ansonsten ist es wahrscheinlich Overkill dafür jeder Klasse eine Referenz auf sich selbt zurückgeben zu lassen, nur damit man das ev. mal machen kann. (Rückgabewerte kann man da ja auch nicht mehr so schön einbringen)

Bei volkards Beispiel würde ich die erste Variante bevorzugen.
In wirklichem Code würde wahrscheinlich die letzte Variante sehr merkwürdig aussehen..

fr33g

Leute ich kapier des mit den bits no net so ganz. Will jetzt zum bispiel flags setzen. Mach ich mir dann einfach eine char variable die ja 8 bit hat. So und dann muss ich gucken den buchstabe den ich der variable gebe welchem zahlenwert der entspricht und damm schaun wie davon die binäre zahl aussieht? Wenn ich dann genau das 4. Bit ändern will muss ich dass ja mit und oder oder so machen. Und wie kann ich dann z.b abfragen ob genau das 4. Bit true ist?

Danke schonmal;-)

Fellhuhn

Warum nicht einfach std::bitset verwenden?

// Bits:
std::bitset<32> myBits;

// Bits vertauschen:
std::swap(myBits[3], myBits[5]);

// Abfragen:
if (myBits.test(4)) ...

Warum immer kompliziert?

char a = 0;      // kein Bit gesetzt (Bit 0 bis 7 == 0)

    a = (a | 1<<3);  // Bit 3 setzen ( or )
    a = (a ^ 1<<3);  // Bit 3 umkippen (toggeln) (xor) ist nun wieder 0  
    a = (a & 1<<3);  // Bit 3 testen (and) ist 0
    a = (a ^ 1<<3);  // Bit 3 toggle (xor) ist nun 1
    a = (a & 1<<3);  // Bit 3 testen (and) ist 1
    a = (a & ~(1<<3)); // Bit 3 loeschen

Carstig

@Fellhuhn: ich mag deine Antwort! std 4thewin

... aber du mußt den anderen jetzt noch sagen, daß hier die bits von "links" gezählt werden. (Bit 0 ist das Most Significant Bit (MSB), Bit 31 ist das LSB). Nicht daß sich hier einer noch verzählt.

@fr33g: Du kannst mit bitset Deine 8bit Flagge auch lesbarer als mit einem "Buchstaben" initialisieren:

bitset<8> flag (string("01010011"));

Hier die noch mehr Info zum bitset: http://www.cplusplus.com/reference/stl/bitset/

fr33g

ok dankeschön
jetzt kapier ichs=)

bzw eine kleine frage noch:

Wann muss ich von links ab zählen mit 0 und wann von rechts??

Carstig

Das ist eine "Vereinbarungssache" bzw Definitionssache, wann man von links oder rechts zählt.

Was ich sagen will: es gibt Hardware-Architekturen, da ist das Bit ganz links bit #0 (zB Power). Und bei Intel ist Bit#0 ganz rechts.

Bei mir an der Uni wurde immer von rechts gezählt (war ja auch logisch: bit #0 == 2 hoch 0 ). Damals wurde mir erzählt, daß Intel, Motorola etc von rechts zählen und IBM von links. Da war dann von rechts bei mir also normal.

Bei mir in der Firma zählt man immer von Links. Also ist das für mich inzwischen "normal".

fr33g schrieb:

...
bzw eine kleine frage noch:

Wann muss ich von links ab zählen mit 0 und wann von rechts??

Nehm z.B. die Zahl 1 als Wert einer Integer-Variablen, da ist immer das Bit 0 = 1 !
Egal wo dieses Bit in Wirklichkeit im Speicher steht, beim Code schreiben steht es für Dich ganz rechts !
Denn 1 << 1 (Bits um 1 Position nach links schieben) Multiplikation mit 2, 1 << 2 Multiplikation mit 4 usw.
bzw. 1 >> 1 (Bits um 1 Position nach rechts schieben) Division durch 2 (Integerdivision 1/2 = 0)